package cl

func (m *SmallKV) Clone() *SmallKV {
	if m != nil {
		o := &SmallKV{}
		o.K = m.K
		o.V = m.V
		return o
	}
	return nil
}

func InitSmallKV() *SmallKV {
	m := &SmallKV{}
	m.FixNilFields()
	return m
}
func (m *SmallKV) FixNilFields() {
	if m != nil {

	}
}
func (m *SmallK32V64) Clone() *SmallK32V64 {
	if m != nil {
		o := &SmallK32V64{}
		o.K = m.K
		o.V = m.V
		return o
	}
	return nil
}

func InitSmallK32V64() *SmallK32V64 {
	m := &SmallK32V64{}
	m.FixNilFields()
	return m
}
func (m *SmallK32V64) FixNilFields() {
	if m != nil {

	}
}
func (m *Pair) Clone() *Pair {
	if m != nil {
		o := &Pair{}
		o.Key = m.Key
		o.Value = m.Value
		return o
	}
	return nil
}

func InitPair() *Pair {
	m := &Pair{}
	m.FixNilFields()
	return m
}
func (m *Pair) FixNilFields() {
	if m != nil {

	}
}
func (m *Pairs) Clone() *Pairs {
	if m != nil {
		o := &Pairs{}
		if len(m.Pairs) > 0 {
			o.Pairs = make([]*Pair, len(m.Pairs))
			for k, e := range m.Pairs {
				o.Pairs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPairs() *Pairs {
	m := &Pairs{}
	m.FixNilFields()
	return m
}
func (m *Pairs) FixNilFields() {
	if m != nil {

		for _, itor := range m.Pairs {
			itor.FixNilFields()
		}

	}
}
func (m *PairU32) Clone() *PairU32 {
	if m != nil {
		o := &PairU32{}
		o.Key = m.Key
		o.Value = m.Value
		return o
	}
	return nil
}

func InitPairU32() *PairU32 {
	m := &PairU32{}
	m.FixNilFields()
	return m
}
func (m *PairU32) FixNilFields() {
	if m != nil {

	}
}
func (m *PairsU32S) Clone() *PairsU32S {
	if m != nil {
		o := &PairsU32S{}
		if len(m.Pairs) > 0 {
			o.Pairs = make([]*PairU32, len(m.Pairs))
			for k, e := range m.Pairs {
				o.Pairs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPairsU32S() *PairsU32S {
	m := &PairsU32S{}
	m.FixNilFields()
	return m
}
func (m *PairsU32S) FixNilFields() {
	if m != nil {

		for _, itor := range m.Pairs {
			itor.FixNilFields()
		}

	}
}
func (m *Uint32S) Clone() *Uint32S {
	if m != nil {
		o := &Uint32S{}
		if len(m.Values) > 0 {
			o.Values = make([]uint32, len(m.Values))
			copy(o.Values, m.Values)
		}
		return o
	}
	return nil
}

func InitUint32S() *Uint32S {
	m := &Uint32S{}
	m.FixNilFields()
	return m
}
func (m *Uint32S) FixNilFields() {
	if m != nil {

	}
}
func (m *Uint64S) Clone() *Uint64S {
	if m != nil {
		o := &Uint64S{}
		if len(m.Values) > 0 {
			o.Values = make([]uint64, len(m.Values))
			copy(o.Values, m.Values)
		}
		return o
	}
	return nil
}

func InitUint64S() *Uint64S {
	m := &Uint64S{}
	m.FixNilFields()
	return m
}
func (m *Uint64S) FixNilFields() {
	if m != nil {

	}
}
func (m *Int64S) Clone() *Int64S {
	if m != nil {
		o := &Int64S{}
		if len(m.Values) > 0 {
			o.Values = make([]int64, len(m.Values))
			copy(o.Values, m.Values)
		}
		return o
	}
	return nil
}

func InitInt64S() *Int64S {
	m := &Int64S{}
	m.FixNilFields()
	return m
}
func (m *Int64S) FixNilFields() {
	if m != nil {

	}
}
func (m *Int64M) Clone() *Int64M {
	if m != nil {
		o := &Int64M{}
		if len(m.Values) > 0 {
			o.Values = make(map[uint32]int64, len(m.Values))
			for k, e := range m.Values {
				o.Values[k] = e
			}
		}
		return o
	}
	return nil
}

func InitInt64M() *Int64M {
	m := &Int64M{}
	m.FixNilFields()
	return m
}
func (m *Int64M) FixNilFields() {
	if m != nil {

		if m.Values == nil {
			m.Values = make(map[uint32]int64)
		}

	}
}
func (m *USPair) Clone() *USPair {
	if m != nil {
		o := &USPair{}
		o.Key = m.Key
		o.Value = m.Value
		return o
	}
	return nil
}

func InitUSPair() *USPair {
	m := &USPair{}
	m.FixNilFields()
	return m
}
func (m *USPair) FixNilFields() {
	if m != nil {

	}
}
func (m *Attr) Clone() *Attr {
	if m != nil {
		o := &Attr{}
		o.Type = m.Type
		o.Value = m.Value
		return o
	}
	return nil
}

func InitAttr() *Attr {
	m := &Attr{}
	m.FixNilFields()
	return m
}
func (m *Attr) FixNilFields() {
	if m != nil {

	}
}
func (m *Goods) Clone() *Goods {
	if m != nil {
		o := &Goods{}
		o.Id = m.Id
		o.Num = m.Num
		return o
	}
	return nil
}

func InitGoods() *Goods {
	m := &Goods{}
	m.FixNilFields()
	return m
}
func (m *Goods) FixNilFields() {
	if m != nil {

	}
}
func (m *Params) Clone() *Params {
	if m != nil {
		o := &Params{}
		o.Param0 = m.Param0
		o.Param1 = m.Param1
		return o
	}
	return nil
}

func InitParams() *Params {
	m := &Params{}
	m.FixNilFields()
	return m
}
func (m *Params) FixNilFields() {
	if m != nil {

	}
}
func (m *GoodsList) Clone() *GoodsList {
	if m != nil {
		o := &GoodsList{}
		if len(m.List) > 0 {
			o.List = make([]*Goods, len(m.List))
			for k, e := range m.List {
				o.List[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitGoodsList() *GoodsList {
	m := &GoodsList{}
	m.FixNilFields()
	return m
}
func (m *GoodsList) FixNilFields() {
	if m != nil {

		for _, itor := range m.List {
			itor.FixNilFields()
		}

	}
}
func (m *GoodsState) Clone() *GoodsState {
	if m != nil {
		o := &GoodsState{}
		o.Id = m.Id
		o.Count = m.Count
		o.Time = m.Time
		return o
	}
	return nil
}

func InitGoodsState() *GoodsState {
	m := &GoodsState{}
	m.FixNilFields()
	return m
}
func (m *GoodsState) FixNilFields() {
	if m != nil {

	}
}
func (m *BuyProgress) Clone() *BuyProgress {
	if m != nil {
		o := &BuyProgress{}
		o.Group = m.Group
		o.Step = m.Step
		o.Count = m.Count
		return o
	}
	return nil
}

func InitBuyProgress() *BuyProgress {
	m := &BuyProgress{}
	m.FixNilFields()
	return m
}
func (m *BuyProgress) FixNilFields() {
	if m != nil {

	}
}
func (m *ShopGrid) Clone() *ShopGrid {
	if m != nil {
		o := &ShopGrid{}
		o.ResetType = m.ResetType
		o.ResetTime = m.ResetTime
		o.BuyedCount = m.BuyedCount
		return o
	}
	return nil
}

func InitShopGrid() *ShopGrid {
	m := &ShopGrid{}
	m.FixNilFields()
	return m
}
func (m *ShopGrid) FixNilFields() {
	if m != nil {

	}
}
func (m *BuffState) Clone() *BuffState {
	if m != nil {
		o := &BuffState{}
		o.Id = m.Id
		o.Time = m.Time
		return o
	}
	return nil
}

func InitBuffState() *BuffState {
	m := &BuffState{}
	m.FixNilFields()
	return m
}
func (m *BuffState) FixNilFields() {
	if m != nil {

	}
}
func (m *Coordinate) Clone() *Coordinate {
	if m != nil {
		o := &Coordinate{}
		o.Row = m.Row
		o.Col = m.Col
		return o
	}
	return nil
}

func InitCoordinate() *Coordinate {
	m := &Coordinate{}
	m.FixNilFields()
	return m
}
func (m *Coordinate) FixNilFields() {
	if m != nil {

	}
}
func (m *Condition) Clone() *Condition {
	if m != nil {
		o := &Condition{}
		o.Type = m.Type
		if len(m.Details) > 0 {
			o.Details = make(map[uint32]uint64, len(m.Details))
			for k, e := range m.Details {
				o.Details[k] = e
			}
		}
		return o
	}
	return nil
}

func InitCondition() *Condition {
	m := &Condition{}
	m.FixNilFields()
	return m
}
func (m *Condition) FixNilFields() {
	if m != nil {

		if m.Details == nil {
			m.Details = make(map[uint32]uint64)
		}

	}
}
func (m *SyncCondition) Clone() *SyncCondition {
	if m != nil {
		o := &SyncCondition{}
		o.Condition = m.Condition.Clone()
		o.Id = m.Id
		return o
	}
	return nil
}

func InitSyncCondition() *SyncCondition {
	m := &SyncCondition{}
	m.FixNilFields()
	return m
}
func (m *SyncCondition) FixNilFields() {
	if m != nil {

		if m.Condition == nil {
			m.Condition = &Condition{}
		}
		m.Condition.FixNilFields()

	}
}
func (m *ConditionAwarded) Clone() *ConditionAwarded {
	if m != nil {
		o := &ConditionAwarded{}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		o.ReceivedAward = m.ReceivedAward.Clone()
		return o
	}
	return nil
}

func InitConditionAwarded() *ConditionAwarded {
	m := &ConditionAwarded{}
	m.FixNilFields()
	return m
}
func (m *ConditionAwarded) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

		if m.ReceivedAward == nil {
			m.ReceivedAward = &ReceivedAward{}
		}
		m.ReceivedAward.FixNilFields()

	}
}
func (m *ReceivedAward) Clone() *ReceivedAward {
	if m != nil {
		o := &ReceivedAward{}
		o.Id = m.Id
		if len(m.Ids) > 0 {
			o.Ids = make([]uint32, len(m.Ids))
			copy(o.Ids, m.Ids)
		}
		return o
	}
	return nil
}

func InitReceivedAward() *ReceivedAward {
	m := &ReceivedAward{}
	m.FixNilFields()
	return m
}
func (m *ReceivedAward) FixNilFields() {
	if m != nil {

	}
}
func (m *Resource) Clone() *Resource {
	if m != nil {
		o := &Resource{}
		o.Id = m.Id
		o.Type = m.Type
		o.Value = m.Value
		o.Count = m.Count
		if len(m.Attrs) > 0 {
			o.Attrs = make([]*Attr, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		o.Resolve = m.Resolve
		o.Rand = m.Rand
		o.Display = m.Display
		o.ResolveExt = m.ResolveExt.Clone()
		return o
	}
	return nil
}

func InitResource() *Resource {
	m := &Resource{}
	m.FixNilFields()
	return m
}
func (m *Resource) FixNilFields() {
	if m != nil {

		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

		if m.ResolveExt == nil {
			m.ResolveExt = &ResolveExt{}
		}
		m.ResolveExt.FixNilFields()

	}
}
func (m *BigResource) Clone() *BigResource {
	if m != nil {
		o := &BigResource{}
		o.Id = m.Id
		o.Type = m.Type
		o.Value = m.Value
		o.Count = m.Count
		return o
	}
	return nil
}

func InitBigResource() *BigResource {
	m := &BigResource{}
	m.FixNilFields()
	return m
}
func (m *BigResource) FixNilFields() {
	if m != nil {

	}
}
func (m *ResolveExt) Clone() *ResolveExt {
	if m != nil {
		o := &ResolveExt{}
		o.Type = m.Type
		o.Value = m.Value
		o.Count = m.Count
		return o
	}
	return nil
}

func InitResolveExt() *ResolveExt {
	m := &ResolveExt{}
	m.FixNilFields()
	return m
}
func (m *ResolveExt) FixNilFields() {
	if m != nil {

	}
}
func (m *Resources) Clone() *Resources {
	if m != nil {
		o := &Resources{}
		if len(m.Ress) > 0 {
			o.Ress = make([]*Resource, len(m.Ress))
			for k, e := range m.Ress {
				o.Ress[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitResources() *Resources {
	m := &Resources{}
	m.FixNilFields()
	return m
}
func (m *Resources) FixNilFields() {
	if m != nil {

		for _, itor := range m.Ress {
			itor.FixNilFields()
		}

	}
}
func (m *HealthPoint) Clone() *HealthPoint {
	if m != nil {
		o := &HealthPoint{}
		o.Id = m.Id
		o.Hp = m.Hp
		return o
	}
	return nil
}

func InitHealthPoint() *HealthPoint {
	m := &HealthPoint{}
	m.FixNilFields()
	return m
}
func (m *HealthPoint) FixNilFields() {
	if m != nil {

	}
}
func (m *RulesShow) Clone() *RulesShow {
	if m != nil {
		o := &RulesShow{}
		o.Id = m.Id
		o.TierLevel = m.TierLevel
		o.Level = m.Level
		return o
	}
	return nil
}

func InitRulesShow() *RulesShow {
	m := &RulesShow{}
	m.FixNilFields()
	return m
}
func (m *RulesShow) FixNilFields() {
	if m != nil {

	}
}
func (m *UserBattleData) Clone() *UserBattleData {
	if m != nil {
		o := &UserBattleData{}
		o.Name = m.Name
		o.Throne = m.Throne.Clone()
		if len(m.Fashions) > 0 {
			o.Fashions = make([]*Fashion, len(m.Fashions))
			for k, e := range m.Fashions {
				o.Fashions[k] = e.Clone()
			}
		}
		if len(m.Pets) > 0 {
			o.Pets = make([]*Pet, len(m.Pets))
			for k, e := range m.Pets {
				o.Pets[k] = e.Clone()
			}
		}
		if len(m.Equipments) > 0 {
			o.Equipments = make([]*Equipment, len(m.Equipments))
			for k, e := range m.Equipments {
				o.Equipments[k] = e.Clone()
			}
		}
		if len(m.Meridians) > 0 {
			o.Meridians = make([]*Meridian, len(m.Meridians))
			for k, e := range m.Meridians {
				o.Meridians[k] = e.Clone()
			}
		}
		if len(m.Appearances) > 0 {
			o.Appearances = make([]uint32, len(m.Appearances))
			copy(o.Appearances, m.Appearances)
		}
		if len(m.Formations) > 0 {
			o.Formations = make([]*Formation, len(m.Formations))
			for k, e := range m.Formations {
				o.Formations[k] = e.Clone()
			}
		}
		if len(m.Grows) > 0 {
			o.Grows = make([]*FormationGrow, len(m.Grows))
			for k, e := range m.Grows {
				o.Grows[k] = e.Clone()
			}
		}
		if len(m.Wears) > 0 {
			o.Wears = make([]*FormationWear, len(m.Wears))
			for k, e := range m.Wears {
				o.Wears[k] = e.Clone()
			}
		}
		if len(m.MainSkills) > 0 {
			o.MainSkills = make(map[uint32]uint32, len(m.MainSkills))
			for k, e := range m.MainSkills {
				o.MainSkills[k] = e
			}
		}
		if len(m.MainSkillBook) > 0 {
			o.MainSkillBook = make(map[uint32]uint32, len(m.MainSkillBook))
			for k, e := range m.MainSkillBook {
				o.MainSkillBook[k] = e
			}
		}
		if len(m.BattlePos) > 0 {
			o.BattlePos = make(map[uint32]uint32, len(m.BattlePos))
			for k, e := range m.BattlePos {
				o.BattlePos[k] = e
			}
		}
		o.SwordForgingInheritId = m.SwordForgingInheritId
		if len(m.SupportThrones) > 0 {
			o.SupportThrones = make([]*Throne, len(m.SupportThrones))
			for k, e := range m.SupportThrones {
				o.SupportThrones[k] = e.Clone()
			}
		}
		if len(m.Horcruxes) > 0 {
			o.Horcruxes = make([]*Horcrux, len(m.Horcruxes))
			for k, e := range m.Horcruxes {
				o.Horcruxes[k] = e.Clone()
			}
		}
		o.TreasureData = m.TreasureData.Clone()
		if len(m.Rules) > 0 {
			o.Rules = make([]*RulesShow, len(m.Rules))
			for k, e := range m.Rules {
				o.Rules[k] = e.Clone()
			}
		}
		if len(m.SupportFashions) > 0 {
			o.SupportFashions = make([]*Fashion, len(m.SupportFashions))
			for k, e := range m.SupportFashions {
				o.SupportFashions[k] = e.Clone()
			}
		}
		if len(m.OperationThrones) > 0 {
			o.OperationThrones = make([]*Throne, len(m.OperationThrones))
			for k, e := range m.OperationThrones {
				o.OperationThrones[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitUserBattleData() *UserBattleData {
	m := &UserBattleData{}
	m.FixNilFields()
	return m
}
func (m *UserBattleData) FixNilFields() {
	if m != nil {

		if m.Throne == nil {
			m.Throne = &Throne{}
		}
		m.Throne.FixNilFields()

		for _, itor := range m.Fashions {
			itor.FixNilFields()
		}

		for _, itor := range m.Pets {
			itor.FixNilFields()
		}

		for _, itor := range m.Equipments {
			itor.FixNilFields()
		}

		for _, itor := range m.Meridians {
			itor.FixNilFields()
		}

		for _, itor := range m.Formations {
			itor.FixNilFields()
		}

		for _, itor := range m.Grows {
			itor.FixNilFields()
		}

		for _, itor := range m.Wears {
			itor.FixNilFields()
		}

		if m.MainSkills == nil {
			m.MainSkills = make(map[uint32]uint32)
		}

		if m.MainSkillBook == nil {
			m.MainSkillBook = make(map[uint32]uint32)
		}

		if m.BattlePos == nil {
			m.BattlePos = make(map[uint32]uint32)
		}

		for _, itor := range m.SupportThrones {
			itor.FixNilFields()
		}

		for _, itor := range m.Horcruxes {
			itor.FixNilFields()
		}

		if m.TreasureData == nil {
			m.TreasureData = &TreasureData{}
		}
		m.TreasureData.FixNilFields()

		for _, itor := range m.Rules {
			itor.FixNilFields()
		}

		for _, itor := range m.SupportFashions {
			itor.FixNilFields()
		}

		for _, itor := range m.OperationThrones {
			itor.FixNilFields()
		}

	}
}
func (m *TreasureData) Clone() *TreasureData {
	if m != nil {
		o := &TreasureData{}
		if len(m.Treasures) > 0 {
			o.Treasures = make([]*SmallKV, len(m.Treasures))
			for k, e := range m.Treasures {
				o.Treasures[k] = e.Clone()
			}
		}
		if len(m.Pets) > 0 {
			o.Pets = make([]*PairU32, len(m.Pets))
			for k, e := range m.Pets {
				o.Pets[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitTreasureData() *TreasureData {
	m := &TreasureData{}
	m.FixNilFields()
	return m
}
func (m *TreasureData) FixNilFields() {
	if m != nil {

		for _, itor := range m.Treasures {
			itor.FixNilFields()
		}

		for _, itor := range m.Pets {
			itor.FixNilFields()
		}

	}
}
func (m *RankValue) Clone() *RankValue {
	if m != nil {
		o := &RankValue{}
		o.Value = m.Value
		o.User = m.User.Clone()
		o.Value2 = m.Value2
		if len(m.PetFormations) > 0 {
			o.PetFormations = make([]*PetFormation, len(m.PetFormations))
			for k, e := range m.PetFormations {
				o.PetFormations[k] = e.Clone()
			}
		}
		o.League = m.League.Clone()
		return o
	}
	return nil
}

func InitRankValue() *RankValue {
	m := &RankValue{}
	m.FixNilFields()
	return m
}
func (m *RankValue) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

		for _, itor := range m.PetFormations {
			itor.FixNilFields()
		}

		if m.League == nil {
			m.League = &LeagueSnapshot{}
		}
		m.League.FixNilFields()

	}
}
func (m *PetFormation) Clone() *PetFormation {
	if m != nil {
		o := &PetFormation{}
		o.FmtPos = m.FmtPos
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.Level = m.Level
		o.Star = m.Star
		o.Skin = m.Skin
		return o
	}
	return nil
}

func InitPetFormation() *PetFormation {
	m := &PetFormation{}
	m.FixNilFields()
	return m
}
func (m *PetFormation) FixNilFields() {
	if m != nil {

	}
}
func (m *RankIdScore) Clone() *RankIdScore {
	if m != nil {
		o := &RankIdScore{}
		o.Rank = m.Rank
		o.Id = m.Id
		o.Score = m.Score
		return o
	}
	return nil
}

func InitRankIdScore() *RankIdScore {
	m := &RankIdScore{}
	m.FixNilFields()
	return m
}
func (m *RankIdScore) FixNilFields() {
	if m != nil {

	}
}
func (m *RankScoreIds) Clone() *RankScoreIds {
	if m != nil {
		o := &RankScoreIds{}
		o.Rank = m.Rank
		o.Score = m.Score
		if len(m.Ids) > 0 {
			o.Ids = make([]uint64, len(m.Ids))
			copy(o.Ids, m.Ids)
		}
		return o
	}
	return nil
}

func InitRankScoreIds() *RankScoreIds {
	m := &RankScoreIds{}
	m.FixNilFields()
	return m
}
func (m *RankScoreIds) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueRankValue) Clone() *LeagueRankValue {
	if m != nil {
		o := &LeagueRankValue{}
		o.Value = m.Value
		o.Value2 = m.Value2
		o.League = m.League.Clone()
		return o
	}
	return nil
}

func InitLeagueRankValue() *LeagueRankValue {
	m := &LeagueRankValue{}
	m.FixNilFields()
	return m
}
func (m *LeagueRankValue) FixNilFields() {
	if m != nil {

		if m.League == nil {
			m.League = &LeagueSnapshot{}
		}
		m.League.FixNilFields()

	}
}
func (m *AoiUser) Clone() *AoiUser {
	if m != nil {
		o := &AoiUser{}
		o.RoomTitleRank = m.RoomTitleRank
		o.LeagueTitleRank = m.LeagueTitleRank
		o.Snap = m.Snap.Clone()
		return o
	}
	return nil
}

func InitAoiUser() *AoiUser {
	m := &AoiUser{}
	m.FixNilFields()
	return m
}
func (m *AoiUser) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *UserSnapshot) Clone() *UserSnapshot {
	if m != nil {
		o := &UserSnapshot{}
		o.Id = m.Id
		o.Name = m.Name
		o.Level = m.Level
		o.Career = m.Career
		o.BaseId = m.BaseId
		o.Star = m.Star
		o.Power = m.Power
		o.Hp = m.Hp
		o.OfflineTime = m.OfflineTime
		o.Online = m.Online
		o.Faction = m.Faction
		o.Goodness = m.Goodness
		o.Evil = m.Evil
		o.CreateTime = m.CreateTime
		o.League = m.League
		o.LeagueName = m.LeagueName
		o.FashionId = m.FashionId
		o.Credits = m.Credits
		o.ServerId = m.ServerId
		if len(m.Books) > 0 {
			o.Books = make([]*DiaryBook, len(m.Books))
			for k, e := range m.Books {
				o.Books[k] = e.Clone()
			}
		}
		o.StarId = m.StarId
		if len(m.Appearances) > 0 {
			o.Appearances = make([]uint32, len(m.Appearances))
			copy(o.Appearances, m.Appearances)
		}
		o.SnapshotType = m.SnapshotType
		o.SwordForgingInheritId = m.SwordForgingInheritId
		o.LeagueLevel = m.LeagueLevel
		o.LeagueBadge = m.LeagueBadge
		if len(m.Treasures) > 0 {
			o.Treasures = make([]uint32, len(m.Treasures))
			copy(o.Treasures, m.Treasures)
		}
		o.FashionStar = m.FashionStar
		o.Fashion = m.Fashion.Clone()
		o.LevelStep = m.LevelStep
		return o
	}
	return nil
}

func InitUserSnapshot() *UserSnapshot {
	m := &UserSnapshot{}
	m.FixNilFields()
	return m
}
func (m *UserSnapshot) FixNilFields() {
	if m != nil {

		for _, itor := range m.Books {
			itor.FixNilFields()
		}

		if m.Fashion == nil {
			m.Fashion = &ShowFashion{}
		}
		m.Fashion.FixNilFields()

	}
}
func (m *ShowFashion) Clone() *ShowFashion {
	if m != nil {
		o := &ShowFashion{}
		o.Id = m.Id
		o.Star = m.Star
		return o
	}
	return nil
}

func InitShowFashion() *ShowFashion {
	m := &ShowFashion{}
	m.FixNilFields()
	return m
}
func (m *ShowFashion) FixNilFields() {
	if m != nil {

	}
}
func (m *User) Clone() *User {
	if m != nil {
		o := &User{}
		o.Id = m.Id
		o.Name = m.Name
		o.Level = m.Level
		o.ServerId = m.ServerId
		o.BaseId = m.BaseId
		o.Money = m.Money
		o.Gold = m.Gold
		o.Exp = m.Exp
		o.Energy = m.Energy
		o.CreateTime = m.CreateTime
		o.Star = m.Star
		if len(m.Currency) > 0 {
			o.Currency = make([]uint64, len(m.Currency))
			copy(o.Currency, m.Currency)
		}
		o.BodyStage = m.BodyStage
		o.BodyFull = m.BodyFull
		o.Vip = m.Vip
		o.VipExp = m.VipExp
		o.LeagueId = m.LeagueId
		o.LeagueName = m.LeagueName
		o.RechargeAmount = m.RechargeAmount
		o.Age = m.Age
		o.LeagueLevel = m.LeagueLevel
		if len(m.FinishedWorldchapterEvt) > 0 {
			o.FinishedWorldchapterEvt = make([]uint32, len(m.FinishedWorldchapterEvt))
			copy(o.FinishedWorldchapterEvt, m.FinishedWorldchapterEvt)
		}
		o.PracticeAddition = m.PracticeAddition
		o.SoarLvl = m.SoarLvl
		o.StarId = m.StarId
		o.RehabilitateStart = m.RehabilitateStart
		o.RehabilitatePillCount = m.RehabilitatePillCount
		if len(m.Appearances) > 0 {
			o.Appearances = make([]uint32, len(m.Appearances))
			copy(o.Appearances, m.Appearances)
		}
		if len(m.FinishedRelaxedEvt) > 0 {
			o.FinishedRelaxedEvt = make([]uint32, len(m.FinishedRelaxedEvt))
			copy(o.FinishedRelaxedEvt, m.FinishedRelaxedEvt)
		}
		if len(m.Yokes) > 0 {
			o.Yokes = make([]uint32, len(m.Yokes))
			copy(o.Yokes, m.Yokes)
		}
		o.SwordForgingInheritId = m.SwordForgingInheritId
		o.RechargeScore = m.RechargeScore
		o.LastLeaveTm = m.LastLeaveTm
		o.NameChangeCount = m.NameChangeCount
		if len(m.Strengths) > 0 {
			o.Strengths = make([]*Strength, len(m.Strengths))
			for k, e := range m.Strengths {
				o.Strengths[k] = e.Clone()
			}
		}
		o.RechargeMoney = m.RechargeMoney
		o.RelicsCoin = m.RelicsCoin
		o.RulesFrontExp = m.RulesFrontExp
		o.AnotherWorldUnlock = m.AnotherWorldUnlock
		o.FinishAnotherWorldGuide = m.FinishAnotherWorldGuide
		if len(m.PrincipleExps) > 0 {
			o.PrincipleExps = make(map[uint32]uint64, len(m.PrincipleExps))
			for k, e := range m.PrincipleExps {
				o.PrincipleExps[k] = e
			}
		}
		if len(m.StarPeakCurrencies) > 0 {
			o.StarPeakCurrencies = make(map[uint32]uint64, len(m.StarPeakCurrencies))
			for k, e := range m.StarPeakCurrencies {
				o.StarPeakCurrencies[k] = e
			}
		}
		o.LevelStep = m.LevelStep
		if len(m.TourActivityScores) > 0 {
			o.TourActivityScores = make(map[uint32]uint64, len(m.TourActivityScores))
			for k, e := range m.TourActivityScores {
				o.TourActivityScores[k] = e
			}
		}
		o.CurrentChapterId = m.CurrentChapterId
		o.IsMergedServer = m.IsMergedServer
		return o
	}
	return nil
}

func InitUser() *User {
	m := &User{}
	m.FixNilFields()
	return m
}
func (m *User) FixNilFields() {
	if m != nil {

		for _, itor := range m.Strengths {
			itor.FixNilFields()
		}

		if m.PrincipleExps == nil {
			m.PrincipleExps = make(map[uint32]uint64)
		}

		if m.StarPeakCurrencies == nil {
			m.StarPeakCurrencies = make(map[uint32]uint64)
		}

		if m.TourActivityScores == nil {
			m.TourActivityScores = make(map[uint32]uint64)
		}

	}
}
func (m *BattleStatUnit) Clone() *BattleStatUnit {
	if m != nil {
		o := &BattleStatUnit{}
		o.Pos = m.Pos
		o.Val = m.Val
		o.Percent = m.Percent
		return o
	}
	return nil
}

func InitBattleStatUnit() *BattleStatUnit {
	m := &BattleStatUnit{}
	m.FixNilFields()
	return m
}
func (m *BattleStatUnit) FixNilFields() {
	if m != nil {

	}
}
func (m *BattleStat) Clone() *BattleStat {
	if m != nil {
		o := &BattleStat{}
		if len(m.Atks) > 0 {
			o.Atks = make([]*BattleStatUnit, len(m.Atks))
			for k, e := range m.Atks {
				o.Atks[k] = e.Clone()
			}
		}
		if len(m.Defs) > 0 {
			o.Defs = make([]*BattleStatUnit, len(m.Defs))
			for k, e := range m.Defs {
				o.Defs[k] = e.Clone()
			}
		}
		if len(m.Heals) > 0 {
			o.Heals = make([]*BattleStatUnit, len(m.Heals))
			for k, e := range m.Heals {
				o.Heals[k] = e.Clone()
			}
		}
		o.SelfTeamGoodBuffNum = m.SelfTeamGoodBuffNum
		o.EnemyTeamBadBuffNum = m.EnemyTeamBadBuffNum
		o.EnemyTeamKillSkillNum = m.EnemyTeamKillSkillNum
		return o
	}
	return nil
}

func InitBattleStat() *BattleStat {
	m := &BattleStat{}
	m.FixNilFields()
	return m
}
func (m *BattleStat) FixNilFields() {
	if m != nil {

		for _, itor := range m.Atks {
			itor.FixNilFields()
		}

		for _, itor := range m.Defs {
			itor.FixNilFields()
		}

		for _, itor := range m.Heals {
			itor.FixNilFields()
		}

	}
}
func (m *BattleReport) Clone() *BattleReport {
	if m != nil {
		o := &BattleReport{}
		o.Id = m.Id
		o.Formation = m.Formation.Clone()
		if len(m.PrepareDynamics) > 0 {
			o.PrepareDynamics = make([]*BattleDynamic, len(m.PrepareDynamics))
			for k, e := range m.PrepareDynamics {
				o.PrepareDynamics[k] = e.Clone()
			}
		}
		if len(m.Rounds) > 0 {
			o.Rounds = make([]*BattleRound, len(m.Rounds))
			for k, e := range m.Rounds {
				o.Rounds[k] = e.Clone()
			}
		}
		o.Win = m.Win
		o.Stat = m.Stat.Clone()
		o.EndFormation = m.EndFormation.Clone()
		o.WinBossHarmMode = m.WinBossHarmMode
		o.Analyze = m.Analyze.Clone()
		o.Section = m.Section.Clone()
		o.Cond = m.Cond.Clone()
		return o
	}
	return nil
}

func InitBattleReport() *BattleReport {
	m := &BattleReport{}
	m.FixNilFields()
	return m
}
func (m *BattleReport) FixNilFields() {
	if m != nil {

		if m.Formation == nil {
			m.Formation = &BattleFormation{}
		}
		m.Formation.FixNilFields()

		for _, itor := range m.PrepareDynamics {
			itor.FixNilFields()
		}

		for _, itor := range m.Rounds {
			itor.FixNilFields()
		}

		if m.Stat == nil {
			m.Stat = &BattleStat{}
		}
		m.Stat.FixNilFields()

		if m.EndFormation == nil {
			m.EndFormation = &BattleFormation{}
		}
		m.EndFormation.FixNilFields()

		if m.Analyze == nil {
			m.Analyze = &BattleAnalyze{}
		}
		m.Analyze.FixNilFields()

		if m.Section == nil {
			m.Section = &BattleSection{}
		}
		m.Section.FixNilFields()

		if m.Cond == nil {
			m.Cond = &BattleCondition{}
		}
		m.Cond.FixNilFields()

	}
}
func (m *BattleSection) Clone() *BattleSection {
	if m != nil {
		o := &BattleSection{}
		o.Rounds = m.Rounds
		o.Start = m.Start
		o.End = m.End
		return o
	}
	return nil
}

func InitBattleSection() *BattleSection {
	m := &BattleSection{}
	m.FixNilFields()
	return m
}
func (m *BattleSection) FixNilFields() {
	if m != nil {

	}
}
func (m *BattleCondition) Clone() *BattleCondition {
	if m != nil {
		o := &BattleCondition{}
		o.Type = m.Type
		o.Value = m.Value
		o.Value2 = m.Value2
		o.ResultValue = m.ResultValue
		o.ResultValue2 = m.ResultValue2
		return o
	}
	return nil
}

func InitBattleCondition() *BattleCondition {
	m := &BattleCondition{}
	m.FixNilFields()
	return m
}
func (m *BattleCondition) FixNilFields() {
	if m != nil {

	}
}
func (m *MiniReport) Clone() *MiniReport {
	if m != nil {
		o := &MiniReport{}
		o.SelfHp = m.SelfHp
		o.EnemyHp = m.EnemyHp
		o.Win = m.Win
		o.Stat = m.Stat.Clone()
		return o
	}
	return nil
}

func InitMiniReport() *MiniReport {
	m := &MiniReport{}
	m.FixNilFields()
	return m
}
func (m *MiniReport) FixNilFields() {
	if m != nil {

		if m.Stat == nil {
			m.Stat = &MiniStat{}
		}
		m.Stat.FixNilFields()

	}
}
func (m *MiniStat) Clone() *MiniStat {
	if m != nil {
		o := &MiniStat{}
		if len(m.Rounds) > 0 {
			o.Rounds = make([]*MiniRound, len(m.Rounds))
			for k, e := range m.Rounds {
				o.Rounds[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitMiniStat() *MiniStat {
	m := &MiniStat{}
	m.FixNilFields()
	return m
}
func (m *MiniStat) FixNilFields() {
	if m != nil {

		for _, itor := range m.Rounds {
			itor.FixNilFields()
		}

	}
}
func (m *MiniAction) Clone() *MiniAction {
	if m != nil {
		o := &MiniAction{}
		o.Skill = m.Skill
		o.IsHurt = m.IsHurt
		o.TotalChange = m.TotalChange
		return o
	}
	return nil
}

func InitMiniAction() *MiniAction {
	m := &MiniAction{}
	m.FixNilFields()
	return m
}
func (m *MiniAction) FixNilFields() {
	if m != nil {

	}
}
func (m *MiniRound) Clone() *MiniRound {
	if m != nil {
		o := &MiniRound{}
		o.SelfAction = m.SelfAction.Clone()
		o.EnemyAction = m.EnemyAction.Clone()
		return o
	}
	return nil
}

func InitMiniRound() *MiniRound {
	m := &MiniRound{}
	m.FixNilFields()
	return m
}
func (m *MiniRound) FixNilFields() {
	if m != nil {

		if m.SelfAction == nil {
			m.SelfAction = &MiniAction{}
		}
		m.SelfAction.FixNilFields()

		if m.EnemyAction == nil {
			m.EnemyAction = &MiniAction{}
		}
		m.EnemyAction.FixNilFields()

	}
}
func (m *BattleAnalyze) Clone() *BattleAnalyze {
	if m != nil {
		o := &BattleAnalyze{}
		o.Elapse = m.Elapse
		return o
	}
	return nil
}

func InitBattleAnalyze() *BattleAnalyze {
	m := &BattleAnalyze{}
	m.FixNilFields()
	return m
}
func (m *BattleAnalyze) FixNilFields() {
	if m != nil {

	}
}
func (m *BattleResult) Clone() *BattleResult {
	if m != nil {
		o := &BattleResult{}
		o.ReportId = m.ReportId
		o.Win = m.Win
		return o
	}
	return nil
}

func InitBattleResult() *BattleResult {
	m := &BattleResult{}
	m.FixNilFields()
	return m
}
func (m *BattleResult) FixNilFields() {
	if m != nil {

	}
}
func (m *BattleResults) Clone() *BattleResults {
	if m != nil {
		o := &BattleResults{}
		if len(m.Results) > 0 {
			o.Results = make([]*BattleResult, len(m.Results))
			for k, e := range m.Results {
				o.Results[k] = e.Clone()
			}
		}
		if len(m.Formations) > 0 {
			o.Formations = make([]*BattleFormation, len(m.Formations))
			for k, e := range m.Formations {
				o.Formations[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBattleResults() *BattleResults {
	m := &BattleResults{}
	m.FixNilFields()
	return m
}
func (m *BattleResults) FixNilFields() {
	if m != nil {

		for _, itor := range m.Results {
			itor.FixNilFields()
		}

		for _, itor := range m.Formations {
			itor.FixNilFields()
		}

	}
}
func (m *BattleFighter) Clone() *BattleFighter {
	if m != nil {
		o := &BattleFighter{}
		o.Id = m.Id
		o.Pos = m.Pos
		o.Base = m.Base
		o.Name = m.Name
		o.Hp = m.Hp
		o.MaxHp = m.MaxHp
		o.Ftype = m.Ftype
		if len(m.Skill) > 0 {
			o.Skill = make([]uint32, len(m.Skill))
			copy(o.Skill, m.Skill)
		}
		o.Level = m.Level
		o.Power = m.Power
		o.Star = m.Star
		if len(m.Appearances) > 0 {
			o.Appearances = make([]uint32, len(m.Appearances))
			copy(o.Appearances, m.Appearances)
		}
		o.Stage = m.Stage
		o.HorcruxBaseId = m.HorcruxBaseId
		o.Quality = m.Quality
		o.Attrs = m.Attrs
		o.Skin = m.Skin
		o.Sp = m.Sp
		o.MaxSp = m.MaxSp
		return o
	}
	return nil
}

func InitBattleFighter() *BattleFighter {
	m := &BattleFighter{}
	m.FixNilFields()
	return m
}
func (m *BattleFighter) FixNilFields() {
	if m != nil {

	}
}
func (m *ModifyAttrInfo) Clone() *ModifyAttrInfo {
	if m != nil {
		o := &ModifyAttrInfo{}
		o.Attr = m.Attr
		o.Val = m.Val
		o.Pos = m.Pos
		o.Type = m.Type
		o.TypeValue = m.TypeValue
		o.Round = m.Round
		return o
	}
	return nil
}

func InitModifyAttrInfo() *ModifyAttrInfo {
	m := &ModifyAttrInfo{}
	m.FixNilFields()
	return m
}
func (m *ModifyAttrInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *BattleDisplayAddition) Clone() *BattleDisplayAddition {
	if m != nil {
		o := &BattleDisplayAddition{}
		o.FashionId = m.FashionId
		o.MonsterTeamId = m.MonsterTeamId
		o.SwordForgingInheritId = m.SwordForgingInheritId
		o.Suppress = m.Suppress
		o.FashionStar = m.FashionStar
		o.FashionSupportValue = m.FashionSupportValue
		return o
	}
	return nil
}

func InitBattleDisplayAddition() *BattleDisplayAddition {
	m := &BattleDisplayAddition{}
	m.FixNilFields()
	return m
}
func (m *BattleDisplayAddition) FixNilFields() {
	if m != nil {

	}
}
func (m *BattleFormation) Clone() *BattleFormation {
	if m != nil {
		o := &BattleFormation{}
		if len(m.Selfs) > 0 {
			o.Selfs = make([]*BattleFighter, len(m.Selfs))
			for k, e := range m.Selfs {
				o.Selfs[k] = e.Clone()
			}
		}
		if len(m.Enemys) > 0 {
			o.Enemys = make([]*BattleFighter, len(m.Enemys))
			for k, e := range m.Enemys {
				o.Enemys[k] = e.Clone()
			}
		}
		o.SelfDisplayAddition = m.SelfDisplayAddition.Clone()
		o.EnemyDisplayAddition = m.EnemyDisplayAddition.Clone()
		return o
	}
	return nil
}

func InitBattleFormation() *BattleFormation {
	m := &BattleFormation{}
	m.FixNilFields()
	return m
}
func (m *BattleFormation) FixNilFields() {
	if m != nil {

		for _, itor := range m.Selfs {
			itor.FixNilFields()
		}

		for _, itor := range m.Enemys {
			itor.FixNilFields()
		}

		if m.SelfDisplayAddition == nil {
			m.SelfDisplayAddition = &BattleDisplayAddition{}
		}
		m.SelfDisplayAddition.FixNilFields()

		if m.EnemyDisplayAddition == nil {
			m.EnemyDisplayAddition = &BattleDisplayAddition{}
		}
		m.EnemyDisplayAddition.FixNilFields()

	}
}
func (m *BattleBriefFighter) Clone() *BattleBriefFighter {
	if m != nil {
		o := &BattleBriefFighter{}
		o.Pos = m.Pos
		o.Hp = m.Hp
		return o
	}
	return nil
}

func InitBattleBriefFighter() *BattleBriefFighter {
	m := &BattleBriefFighter{}
	m.FixNilFields()
	return m
}
func (m *BattleBriefFighter) FixNilFields() {
	if m != nil {

	}
}
func (m *BattleBriefFormation) Clone() *BattleBriefFormation {
	if m != nil {
		o := &BattleBriefFormation{}
		if len(m.Selfs) > 0 {
			o.Selfs = make([]*BattleBriefFighter, len(m.Selfs))
			for k, e := range m.Selfs {
				o.Selfs[k] = e.Clone()
			}
		}
		if len(m.Enemys) > 0 {
			o.Enemys = make([]*BattleBriefFighter, len(m.Enemys))
			for k, e := range m.Enemys {
				o.Enemys[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBattleBriefFormation() *BattleBriefFormation {
	m := &BattleBriefFormation{}
	m.FixNilFields()
	return m
}
func (m *BattleBriefFormation) FixNilFields() {
	if m != nil {

		for _, itor := range m.Selfs {
			itor.FixNilFields()
		}

		for _, itor := range m.Enemys {
			itor.FixNilFields()
		}

	}
}
func (m *BattleRound) Clone() *BattleRound {
	if m != nil {
		o := &BattleRound{}
		if len(m.StartDynamics) > 0 {
			o.StartDynamics = make([]*BattleDynamic, len(m.StartDynamics))
			for k, e := range m.StartDynamics {
				o.StartDynamics[k] = e.Clone()
			}
		}
		if len(m.Actions) > 0 {
			o.Actions = make([]*BattleAction, len(m.Actions))
			for k, e := range m.Actions {
				o.Actions[k] = e.Clone()
			}
		}
		if len(m.EndDynamics) > 0 {
			o.EndDynamics = make([]*BattleDynamic, len(m.EndDynamics))
			for k, e := range m.EndDynamics {
				o.EndDynamics[k] = e.Clone()
			}
		}
		if len(m.DeadPos) > 0 {
			o.DeadPos = make([]int32, len(m.DeadPos))
			copy(o.DeadPos, m.DeadPos)
		}
		return o
	}
	return nil
}

func InitBattleRound() *BattleRound {
	m := &BattleRound{}
	m.FixNilFields()
	return m
}
func (m *BattleRound) FixNilFields() {
	if m != nil {

		for _, itor := range m.StartDynamics {
			itor.FixNilFields()
		}

		for _, itor := range m.Actions {
			itor.FixNilFields()
		}

		for _, itor := range m.EndDynamics {
			itor.FixNilFields()
		}

	}
}
func (m *BattleAction) Clone() *BattleAction {
	if m != nil {
		o := &BattleAction{}
		if len(m.Dynamics) > 0 {
			o.Dynamics = make([]*BattleDynamic, len(m.Dynamics))
			for k, e := range m.Dynamics {
				o.Dynamics[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBattleAction() *BattleAction {
	m := &BattleAction{}
	m.FixNilFields()
	return m
}
func (m *BattleAction) FixNilFields() {
	if m != nil {

		for _, itor := range m.Dynamics {
			itor.FixNilFields()
		}

	}
}
func (m *BattleDynamic) Clone() *BattleDynamic {
	if m != nil {
		o := &BattleDynamic{}
		o.Skill = m.Skill.Clone()
		o.Buff = m.Buff.Clone()
		o.DeadPos = m.DeadPos
		o.ActIndex = m.ActIndex
		o.TriggerIndex = m.TriggerIndex
		if len(m.Sps) > 0 {
			o.Sps = make([]*BattleSpChange, len(m.Sps))
			for k, e := range m.Sps {
				o.Sps[k] = e.Clone()
			}
		}
		if len(m.Attrs) > 0 {
			o.Attrs = make([]string, len(m.Attrs))
			copy(o.Attrs, m.Attrs)
		}
		return o
	}
	return nil
}

func InitBattleDynamic() *BattleDynamic {
	m := &BattleDynamic{}
	m.FixNilFields()
	return m
}
func (m *BattleDynamic) FixNilFields() {
	if m != nil {

		if m.Skill == nil {
			m.Skill = &BattleSkill{}
		}
		m.Skill.FixNilFields()

		if m.Buff == nil {
			m.Buff = &BattleBuff{}
		}
		m.Buff.FixNilFields()

		for _, itor := range m.Sps {
			itor.FixNilFields()
		}

	}
}
func (m *BattleSkillPrepare) Clone() *BattleSkillPrepare {
	if m != nil {
		o := &BattleSkillPrepare{}
		o.MorphToSkill = m.MorphToSkill
		o.WaitRound = m.WaitRound
		o.WaitEnd = m.WaitEnd
		return o
	}
	return nil
}

func InitBattleSkillPrepare() *BattleSkillPrepare {
	m := &BattleSkillPrepare{}
	m.FixNilFields()
	return m
}
func (m *BattleSkillPrepare) FixNilFields() {
	if m != nil {

	}
}
func (m *BattleSkill) Clone() *BattleSkill {
	if m != nil {
		o := &BattleSkill{}
		o.ActorPos = m.ActorPos
		o.SkillId = m.SkillId
		o.Prepare = m.Prepare.Clone()
		if len(m.Effects) > 0 {
			o.Effects = make([]*BattleSkillEffect, len(m.Effects))
			for k, e := range m.Effects {
				o.Effects[k] = e.Clone()
			}
		}
		if len(m.Buffs) > 0 {
			o.Buffs = make([]*BattleBuff, len(m.Buffs))
			for k, e := range m.Buffs {
				o.Buffs[k] = e.Clone()
			}
		}
		o.SkinId = m.SkinId
		o.Sp = m.Sp.Clone()
		return o
	}
	return nil
}

func InitBattleSkill() *BattleSkill {
	m := &BattleSkill{}
	m.FixNilFields()
	return m
}
func (m *BattleSkill) FixNilFields() {
	if m != nil {

		if m.Prepare == nil {
			m.Prepare = &BattleSkillPrepare{}
		}
		m.Prepare.FixNilFields()

		for _, itor := range m.Effects {
			itor.FixNilFields()
		}

		for _, itor := range m.Buffs {
			itor.FixNilFields()
		}

		if m.Sp == nil {
			m.Sp = &BattleSpChange{}
		}
		m.Sp.FixNilFields()

	}
}
func (m *BattleSkillEffect) Clone() *BattleSkillEffect {
	if m != nil {
		o := &BattleSkillEffect{}
		o.PhaseType = m.PhaseType
		o.TargetPos = m.TargetPos
		if len(m.Hps) > 0 {
			o.Hps = make([]*BattleHpChange, len(m.Hps))
			for k, e := range m.Hps {
				o.Hps[k] = e.Clone()
			}
		}
		if len(m.EffectParams) > 0 {
			o.EffectParams = make([]*BattleSkillEffectParam, len(m.EffectParams))
			for k, e := range m.EffectParams {
				o.EffectParams[k] = e.Clone()
			}
		}
		if len(m.Sps) > 0 {
			o.Sps = make([]*BattleSpChange, len(m.Sps))
			for k, e := range m.Sps {
				o.Sps[k] = e.Clone()
			}
		}
		if len(m.Formula) > 0 {
			o.Formula = make([]string, len(m.Formula))
			copy(o.Formula, m.Formula)
		}
		o.PhaseIndex = m.PhaseIndex
		return o
	}
	return nil
}

func InitBattleSkillEffect() *BattleSkillEffect {
	m := &BattleSkillEffect{}
	m.FixNilFields()
	return m
}
func (m *BattleSkillEffect) FixNilFields() {
	if m != nil {

		for _, itor := range m.Hps {
			itor.FixNilFields()
		}

		for _, itor := range m.EffectParams {
			itor.FixNilFields()
		}

		for _, itor := range m.Sps {
			itor.FixNilFields()
		}

	}
}
func (m *BattleSkillEffectParam) Clone() *BattleSkillEffectParam {
	if m != nil {
		o := &BattleSkillEffectParam{}
		o.Value1 = m.Value1
		o.Value2 = m.Value2
		o.Value3 = m.Value3
		o.Value4 = m.Value4
		o.Value5 = m.Value5
		return o
	}
	return nil
}

func InitBattleSkillEffectParam() *BattleSkillEffectParam {
	m := &BattleSkillEffectParam{}
	m.FixNilFields()
	return m
}
func (m *BattleSkillEffectParam) FixNilFields() {
	if m != nil {

	}
}
func (m *BattleHpChange) Clone() *BattleHpChange {
	if m != nil {
		o := &BattleHpChange{}
		o.Pos = m.Pos
		o.Hurt = m.Hurt
		o.FinalHp = m.FinalHp
		o.Change = m.Change
		o.WouldChange = m.WouldChange
		o.Hit = m.Hit
		o.Crit = m.Crit
		o.Blk = m.Blk
		if len(m.Buffs) > 0 {
			o.Buffs = make([]*BattleHurtThroughBuff, len(m.Buffs))
			for k, e := range m.Buffs {
				o.Buffs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBattleHpChange() *BattleHpChange {
	m := &BattleHpChange{}
	m.FixNilFields()
	return m
}
func (m *BattleHpChange) FixNilFields() {
	if m != nil {

		for _, itor := range m.Buffs {
			itor.FixNilFields()
		}

	}
}
func (m *BattleHurtThroughBuff) Clone() *BattleHurtThroughBuff {
	if m != nil {
		o := &BattleHurtThroughBuff{}
		o.Pos = m.Pos
		o.Buff = m.Buff
		o.Value = m.Value
		o.ActorPos = m.ActorPos
		o.BuffId = m.BuffId
		if len(m.Effects) > 0 {
			o.Effects = make([]*BattleBuffEffectParam, len(m.Effects))
			for k, e := range m.Effects {
				o.Effects[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBattleHurtThroughBuff() *BattleHurtThroughBuff {
	m := &BattleHurtThroughBuff{}
	m.FixNilFields()
	return m
}
func (m *BattleHurtThroughBuff) FixNilFields() {
	if m != nil {

		for _, itor := range m.Effects {
			itor.FixNilFields()
		}

	}
}
func (m *BattleSpThroughBuff) Clone() *BattleSpThroughBuff {
	if m != nil {
		o := &BattleSpThroughBuff{}
		o.Pos = m.Pos
		o.Buff = m.Buff
		o.Value = m.Value
		o.ActorPos = m.ActorPos
		o.BuffId = m.BuffId
		if len(m.Effects) > 0 {
			o.Effects = make([]*BattleBuffEffectParam, len(m.Effects))
			for k, e := range m.Effects {
				o.Effects[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBattleSpThroughBuff() *BattleSpThroughBuff {
	m := &BattleSpThroughBuff{}
	m.FixNilFields()
	return m
}
func (m *BattleSpThroughBuff) FixNilFields() {
	if m != nil {

		for _, itor := range m.Effects {
			itor.FixNilFields()
		}

	}
}
func (m *BattleSpChange) Clone() *BattleSpChange {
	if m != nil {
		o := &BattleSpChange{}
		o.Type = m.Type
		o.Pos = m.Pos
		o.IsAdd = m.IsAdd
		o.Change = m.Change
		o.MaxIsAdd = m.MaxIsAdd
		o.MaxChange = m.MaxChange
		if len(m.Buffs) > 0 {
			o.Buffs = make([]*BattleSpThroughBuff, len(m.Buffs))
			for k, e := range m.Buffs {
				o.Buffs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBattleSpChange() *BattleSpChange {
	m := &BattleSpChange{}
	m.FixNilFields()
	return m
}
func (m *BattleSpChange) FixNilFields() {
	if m != nil {

		for _, itor := range m.Buffs {
			itor.FixNilFields()
		}

	}
}
func (m *BattleBuff) Clone() *BattleBuff {
	if m != nil {
		o := &BattleBuff{}
		o.TargetPos = m.TargetPos
		o.Buff = m.Buff
		if len(m.Hps) > 0 {
			o.Hps = make([]*BattleHpChange, len(m.Hps))
			for k, e := range m.Hps {
				o.Hps[k] = e.Clone()
			}
		}
		o.Rounds = m.Rounds
		o.Disappear = m.Disappear
		o.AttrChanged = m.AttrChanged
		o.Resist = m.Resist
		o.Attach = m.Attach
		o.Id = m.Id
		if len(m.Effects) > 0 {
			o.Effects = make([]*BattleBuffEffectParam, len(m.Effects))
			for k, e := range m.Effects {
				o.Effects[k] = e.Clone()
			}
		}
		o.SkinId = m.SkinId
		if len(m.Sps) > 0 {
			o.Sps = make([]*BattleSpChange, len(m.Sps))
			for k, e := range m.Sps {
				o.Sps[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBattleBuff() *BattleBuff {
	m := &BattleBuff{}
	m.FixNilFields()
	return m
}
func (m *BattleBuff) FixNilFields() {
	if m != nil {

		for _, itor := range m.Hps {
			itor.FixNilFields()
		}

		for _, itor := range m.Effects {
			itor.FixNilFields()
		}

		for _, itor := range m.Sps {
			itor.FixNilFields()
		}

	}
}
func (m *BattleBuffEffectParam) Clone() *BattleBuffEffectParam {
	if m != nil {
		o := &BattleBuffEffectParam{}
		o.Value1 = m.Value1
		o.Value2 = m.Value2
		o.Value3 = m.Value3
		o.Value4 = m.Value4
		return o
	}
	return nil
}

func InitBattleBuffEffectParam() *BattleBuffEffectParam {
	m := &BattleBuffEffectParam{}
	m.FixNilFields()
	return m
}
func (m *BattleBuffEffectParam) FixNilFields() {
	if m != nil {

	}
}
func (m *LevelupHelper) Clone() *LevelupHelper {
	if m != nil {
		o := &LevelupHelper{}
		o.Sid = m.Sid
		o.Uid = m.Uid
		o.Level = m.Level
		o.Tp = m.Tp
		return o
	}
	return nil
}

func InitLevelupHelper() *LevelupHelper {
	m := &LevelupHelper{}
	m.FixNilFields()
	return m
}
func (m *LevelupHelper) FixNilFields() {
	if m != nil {

	}
}
func (m *HelperCnt) Clone() *HelperCnt {
	if m != nil {
		o := &HelperCnt{}
		o.Uid = m.Uid
		o.Cnt = m.Cnt
		return o
	}
	return nil
}

func InitHelperCnt() *HelperCnt {
	m := &HelperCnt{}
	m.FixNilFields()
	return m
}
func (m *HelperCnt) FixNilFields() {
	if m != nil {

	}
}
func (m *BodyPool) Clone() *BodyPool {
	if m != nil {
		o := &BodyPool{}
		o.Id = m.Id
		o.Value = m.Value
		return o
	}
	return nil
}

func InitBodyPool() *BodyPool {
	m := &BodyPool{}
	m.FixNilFields()
	return m
}
func (m *BodyPool) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightBody) Clone() *KnightBody {
	if m != nil {
		o := &KnightBody{}
		o.Stage = m.Stage
		o.WealNum = m.WealNum
		if len(m.Pools) > 0 {
			o.Pools = make([]*BodyPool, len(m.Pools))
			for k, e := range m.Pools {
				o.Pools[k] = e.Clone()
			}
		}
		if len(m.TrainPools) > 0 {
			o.TrainPools = make([]*BodyPool, len(m.TrainPools))
			for k, e := range m.TrainPools {
				o.TrainPools[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitKnightBody() *KnightBody {
	m := &KnightBody{}
	m.FixNilFields()
	return m
}
func (m *KnightBody) FixNilFields() {
	if m != nil {

		for _, itor := range m.Pools {
			itor.FixNilFields()
		}

		for _, itor := range m.TrainPools {
			itor.FixNilFields()
		}

	}
}
func (m *SimulateBattleFighter) Clone() *SimulateBattleFighter {
	if m != nil {
		o := &SimulateBattleFighter{}
		o.Id = m.Id
		o.Name = m.Name
		o.Level = m.Level
		o.BaseId = m.BaseId
		o.Race = m.Race
		o.Career = m.Career
		o.Ftype = m.Ftype
		o.Power = m.Power
		if len(m.Skills) > 0 {
			o.Skills = make([]uint32, len(m.Skills))
			copy(o.Skills, m.Skills)
		}
		if len(m.Attrs) > 0 {
			o.Attrs = make([]int64, len(m.Attrs))
			copy(o.Attrs, m.Attrs)
		}
		o.Star = m.Star
		if len(m.Appearances) > 0 {
			o.Appearances = make([]uint32, len(m.Appearances))
			copy(o.Appearances, m.Appearances)
		}
		o.Stage = m.Stage
		o.HorcruxBaseId = m.HorcruxBaseId
		o.Quality = m.Quality
		o.Skin = m.Skin
		return o
	}
	return nil
}

func InitSimulateBattleFighter() *SimulateBattleFighter {
	m := &SimulateBattleFighter{}
	m.FixNilFields()
	return m
}
func (m *SimulateBattleFighter) FixNilFields() {
	if m != nil {

	}
}
func (m *SimulateBattleFormat) Clone() *SimulateBattleFormat {
	if m != nil {
		o := &SimulateBattleFormat{}
		if len(m.Units) > 0 {
			o.Units = make([]*SimulateBattleFighter, len(m.Units))
			for k, e := range m.Units {
				o.Units[k] = e.Clone()
			}
		}
		o.ThroneId = m.ThroneId
		o.ThroneStar = m.ThroneStar
		o.FashionId = m.FashionId
		o.MonsterTeamId = m.MonsterTeamId
		o.SwordForgingInheritId = m.SwordForgingInheritId
		o.Throne = m.Throne.Clone()
		if len(m.EnvSkills) > 0 {
			o.EnvSkills = make([]uint32, len(m.EnvSkills))
			copy(o.EnvSkills, m.EnvSkills)
		}
		return o
	}
	return nil
}

func InitSimulateBattleFormat() *SimulateBattleFormat {
	m := &SimulateBattleFormat{}
	m.FixNilFields()
	return m
}
func (m *SimulateBattleFormat) FixNilFields() {
	if m != nil {

		for _, itor := range m.Units {
			itor.FixNilFields()
		}

		if m.Throne == nil {
			m.Throne = &SimulateBattleFighter{}
		}
		m.Throne.FixNilFields()

	}
}
func (m *Journal) Clone() *Journal {
	if m != nil {
		o := &Journal{}
		o.FuncId = m.FuncId
		o.GameYear = m.GameYear
		o.Jid = m.Jid
		o.Progress = m.Progress
		if len(m.Values) > 0 {
			o.Values = make([]uint32, len(m.Values))
			copy(o.Values, m.Values)
		}
		o.Index = m.Index
		return o
	}
	return nil
}

func InitJournal() *Journal {
	m := &Journal{}
	m.FixNilFields()
	return m
}
func (m *Journal) FixNilFields() {
	if m != nil {

	}
}
func (m *BattleAttr) Clone() *BattleAttr {
	if m != nil {
		o := &BattleAttr{}
		o.Pos = m.Pos
		o.Power = m.Power
		if len(m.Attrs) > 0 {
			o.Attrs = make([]int64, len(m.Attrs))
			copy(o.Attrs, m.Attrs)
		}
		return o
	}
	return nil
}

func InitBattleAttr() *BattleAttr {
	m := &BattleAttr{}
	m.FixNilFields()
	return m
}
func (m *BattleAttr) FixNilFields() {
	if m != nil {

	}
}
func (m *TeamBattleAttr) Clone() *TeamBattleAttr {
	if m != nil {
		o := &TeamBattleAttr{}
		o.Type = m.Type
		if len(m.BattleAttr) > 0 {
			o.BattleAttr = make([]*BattleAttr, len(m.BattleAttr))
			for k, e := range m.BattleAttr {
				o.BattleAttr[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitTeamBattleAttr() *TeamBattleAttr {
	m := &TeamBattleAttr{}
	m.FixNilFields()
	return m
}
func (m *TeamBattleAttr) FixNilFields() {
	if m != nil {

		for _, itor := range m.BattleAttr {
			itor.FixNilFields()
		}

	}
}
func (m *UseItemParam) Clone() *UseItemParam {
	if m != nil {
		o := &UseItemParam{}
		o.Id = m.Id
		o.Count = m.Count
		o.Param0 = m.Param0
		o.Param1 = m.Param1
		return o
	}
	return nil
}

func InitUseItemParam() *UseItemParam {
	m := &UseItemParam{}
	m.FixNilFields()
	return m
}
func (m *UseItemParam) FixNilFields() {
	if m != nil {

	}
}
func (m *ItemTimeLimitInfo) Clone() *ItemTimeLimitInfo {
	if m != nil {
		o := &ItemTimeLimitInfo{}
		o.Id = m.Id
		o.ExpireTimeType = m.ExpireTimeType
		o.ExpireTime = m.ExpireTime
		return o
	}
	return nil
}

func InitItemTimeLimitInfo() *ItemTimeLimitInfo {
	m := &ItemTimeLimitInfo{}
	m.FixNilFields()
	return m
}
func (m *ItemTimeLimitInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *ItemInfos) Clone() *ItemInfos {
	if m != nil {
		o := &ItemInfos{}
		if len(m.Version) > 0 {
			o.Version = make(map[uint32]uint32, len(m.Version))
			for k, e := range m.Version {
				o.Version[k] = e
			}
		}
		if len(m.TimeLimitInfos) > 0 {
			o.TimeLimitInfos = make([]*ItemTimeLimitInfo, len(m.TimeLimitInfos))
			for k, e := range m.TimeLimitInfos {
				o.TimeLimitInfos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitItemInfos() *ItemInfos {
	m := &ItemInfos{}
	m.FixNilFields()
	return m
}
func (m *ItemInfos) FixNilFields() {
	if m != nil {

		if m.Version == nil {
			m.Version = make(map[uint32]uint32)
		}

		for _, itor := range m.TimeLimitInfos {
			itor.FixNilFields()
		}

	}
}
func (m *ItemTask) Clone() *ItemTask {
	if m != nil {
		o := &ItemTask{}
		o.Id = m.Id
		if len(m.Awarded) > 0 {
			o.Awarded = make([]uint32, len(m.Awarded))
			copy(o.Awarded, m.Awarded)
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitItemTask() *ItemTask {
	m := &ItemTask{}
	m.FixNilFields()
	return m
}
func (m *ItemTask) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *PracticeBuff) Clone() *PracticeBuff {
	if m != nil {
		o := &PracticeBuff{}
		o.Id = m.Id
		o.Etime = m.Etime
		return o
	}
	return nil
}

func InitPracticeBuff() *PracticeBuff {
	m := &PracticeBuff{}
	m.FixNilFields()
	return m
}
func (m *PracticeBuff) FixNilFields() {
	if m != nil {

	}
}
func (m *PracticeTick) Clone() *PracticeTick {
	if m != nil {
		o := &PracticeTick{}
		o.Exp = m.Exp
		return o
	}
	return nil
}

func InitPracticeTick() *PracticeTick {
	m := &PracticeTick{}
	m.FixNilFields()
	return m
}
func (m *PracticeTick) FixNilFields() {
	if m != nil {

	}
}
func (m *PracticeInfo) Clone() *PracticeInfo {
	if m != nil {
		o := &PracticeInfo{}
		if len(m.Buffs) > 0 {
			o.Buffs = make([]*PracticeBuff, len(m.Buffs))
			for k, e := range m.Buffs {
				o.Buffs[k] = e.Clone()
			}
		}
		if len(m.Ticks) > 0 {
			o.Ticks = make([]*PracticeTick, len(m.Ticks))
			for k, e := range m.Ticks {
				o.Ticks[k] = e.Clone()
			}
		}
		o.TickTime = m.TickTime
		o.Exp = m.Exp
		return o
	}
	return nil
}

func InitPracticeInfo() *PracticeInfo {
	m := &PracticeInfo{}
	m.FixNilFields()
	return m
}
func (m *PracticeInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Buffs {
			itor.FixNilFields()
		}

		for _, itor := range m.Ticks {
			itor.FixNilFields()
		}

	}
}
func (m *PracticeOfflineInfo) Clone() *PracticeOfflineInfo {
	if m != nil {
		o := &PracticeOfflineInfo{}
		if len(m.Res) > 0 {
			o.Res = make([]*Resource, len(m.Res))
			for k, e := range m.Res {
				o.Res[k] = e.Clone()
			}
		}
		o.ChanceNum = m.ChanceNum
		o.OfflineSecs = m.OfflineSecs
		return o
	}
	return nil
}

func InitPracticeOfflineInfo() *PracticeOfflineInfo {
	m := &PracticeOfflineInfo{}
	m.FixNilFields()
	return m
}
func (m *PracticeOfflineInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Res {
			itor.FixNilFields()
		}

	}
}
func (m *PracticeBuffOp) Clone() *PracticeBuffOp {
	if m != nil {
		o := &PracticeBuffOp{}
		if len(m.Updates) > 0 {
			o.Updates = make([]*PracticeBuff, len(m.Updates))
			for k, e := range m.Updates {
				o.Updates[k] = e.Clone()
			}
		}
		if len(m.Dels) > 0 {
			o.Dels = make([]uint32, len(m.Dels))
			copy(o.Dels, m.Dels)
		}
		return o
	}
	return nil
}

func InitPracticeBuffOp() *PracticeBuffOp {
	m := &PracticeBuffOp{}
	m.FixNilFields()
	return m
}
func (m *PracticeBuffOp) FixNilFields() {
	if m != nil {

		for _, itor := range m.Updates {
			itor.FixNilFields()
		}

	}
}
func (m *LuckyChanceOp) Clone() *LuckyChanceOp {
	if m != nil {
		o := &LuckyChanceOp{}
		if len(m.Updates) > 0 {
			o.Updates = make([]*LuckyChance, len(m.Updates))
			for k, e := range m.Updates {
				o.Updates[k] = e.Clone()
			}
		}
		if len(m.Dels) > 0 {
			o.Dels = make([]uint32, len(m.Dels))
			copy(o.Dels, m.Dels)
		}
		return o
	}
	return nil
}

func InitLuckyChanceOp() *LuckyChanceOp {
	m := &LuckyChanceOp{}
	m.FixNilFields()
	return m
}
func (m *LuckyChanceOp) FixNilFields() {
	if m != nil {

		for _, itor := range m.Updates {
			itor.FixNilFields()
		}

	}
}
func (m *MailCond) Clone() *MailCond {
	if m != nil {
		o := &MailCond{}
		o.Type = m.Type
		o.Value = m.Value
		o.Ge = m.Ge
		return o
	}
	return nil
}

func InitMailCond() *MailCond {
	m := &MailCond{}
	m.FixNilFields()
	return m
}
func (m *MailCond) FixNilFields() {
	if m != nil {

	}
}
func (m *Mail) Clone() *Mail {
	if m != nil {
		o := &Mail{}
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.CreateTime = m.CreateTime
		o.Flag = m.Flag
		if len(m.Params) > 0 {
			o.Params = make([]string, len(m.Params))
			copy(o.Params, m.Params)
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.Type = m.Type
		if len(m.And) > 0 {
			o.And = make([]*MailCond, len(m.And))
			for k, e := range m.And {
				o.And[k] = e.Clone()
			}
		}
		if len(m.Or) > 0 {
			o.Or = make([]*MailCond, len(m.Or))
			for k, e := range m.Or {
				o.Or[k] = e.Clone()
			}
		}
		o.ExpiredTime = m.ExpiredTime
		o.ProcessId = m.ProcessId
		if len(m.Ops) > 0 {
			o.Ops = make([]uint32, len(m.Ops))
			copy(o.Ops, m.Ops)
		}
		if len(m.Channels) > 0 {
			o.Channels = make([]uint32, len(m.Channels))
			copy(o.Channels, m.Channels)
		}
		o.Vital = m.Vital
		return o
	}
	return nil
}

func InitMail() *Mail {
	m := &Mail{}
	m.FixNilFields()
	return m
}
func (m *Mail) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		for _, itor := range m.And {
			itor.FixNilFields()
		}

		for _, itor := range m.Or {
			itor.FixNilFields()
		}

	}
}
func (m *Tower) Clone() *Tower {
	if m != nil {
		o := &Tower{}
		o.CurId = m.CurId
		o.SweepNum = m.SweepNum
		o.ReceivedAward = m.ReceivedAward.Clone()
		return o
	}
	return nil
}

func InitTower() *Tower {
	m := &Tower{}
	m.FixNilFields()
	return m
}
func (m *Tower) FixNilFields() {
	if m != nil {

		if m.ReceivedAward == nil {
			m.ReceivedAward = &ReceivedAward{}
		}
		m.ReceivedAward.FixNilFields()

	}
}
func (m *Pet) Clone() *Pet {
	if m != nil {
		o := &Pet{}
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.Level = m.Level
		if len(m.Attrs) > 0 {
			o.Attrs = make([]int64, len(m.Attrs))
			copy(o.Attrs, m.Attrs)
		}
		o.Power = m.Power
		o.StarId = m.StarId
		if len(m.Yokes) > 0 {
			o.Yokes = make([]uint32, len(m.Yokes))
			copy(o.Yokes, m.Yokes)
		}
		if len(m.Skills) > 0 {
			o.Skills = make([]*SmallKV, len(m.Skills))
			for k, e := range m.Skills {
				o.Skills[k] = e.Clone()
			}
		}
		o.Skin = m.Skin
		o.AwakeCost = m.AwakeCost.Clone()
		return o
	}
	return nil
}

func InitPet() *Pet {
	m := &Pet{}
	m.FixNilFields()
	return m
}
func (m *Pet) FixNilFields() {
	if m != nil {

		for _, itor := range m.Skills {
			itor.FixNilFields()
		}

		if m.AwakeCost == nil {
			m.AwakeCost = &Resource{}
		}
		m.AwakeCost.FixNilFields()

	}
}
func (m *PetSnapshot) Clone() *PetSnapshot {
	if m != nil {
		o := &PetSnapshot{}
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.StarId = m.StarId
		o.Skin = m.Skin
		o.Power = m.Power
		o.Name = m.Name
		if len(m.Appearances) > 0 {
			o.Appearances = make([]uint32, len(m.Appearances))
			copy(o.Appearances, m.Appearances)
		}
		return o
	}
	return nil
}

func InitPetSnapshot() *PetSnapshot {
	m := &PetSnapshot{}
	m.FixNilFields()
	return m
}
func (m *PetSnapshot) FixNilFields() {
	if m != nil {

	}
}
func (m *UpStarParam) Clone() *UpStarParam {
	if m != nil {
		o := &UpStarParam{}
		o.PetId = m.PetId
		o.Cnt = m.Cnt
		return o
	}
	return nil
}

func InitUpStarParam() *UpStarParam {
	m := &UpStarParam{}
	m.FixNilFields()
	return m
}
func (m *UpStarParam) FixNilFields() {
	if m != nil {

	}
}
func (m *FormationTeam) Clone() *FormationTeam {
	if m != nil {
		o := &FormationTeam{}
		o.Type = m.Type
		o.ThroneId = m.ThroneId
		o.FashionId = m.FashionId
		if len(m.SkillFormat) > 0 {
			o.SkillFormat = make(map[uint32]uint32, len(m.SkillFormat))
			for k, e := range m.SkillFormat {
				o.SkillFormat[k] = e
			}
		}
		if len(m.Formations) > 0 {
			o.Formations = make([]*Formation, len(m.Formations))
			for k, e := range m.Formations {
				o.Formations[k] = e.Clone()
			}
		}
		if len(m.Rules) > 0 {
			o.Rules = make([]uint32, len(m.Rules))
			copy(o.Rules, m.Rules)
		}
		o.LockedObject = m.LockedObject.Clone()
		if len(m.SupportFashions) > 0 {
			o.SupportFashions = make([]uint32, len(m.SupportFashions))
			copy(o.SupportFashions, m.SupportFashions)
		}
		if len(m.OperationThrone) > 0 {
			o.OperationThrone = make([]uint32, len(m.OperationThrone))
			copy(o.OperationThrone, m.OperationThrone)
		}
		return o
	}
	return nil
}

func InitFormationTeam() *FormationTeam {
	m := &FormationTeam{}
	m.FixNilFields()
	return m
}
func (m *FormationTeam) FixNilFields() {
	if m != nil {

		if m.SkillFormat == nil {
			m.SkillFormat = make(map[uint32]uint32)
		}

		for _, itor := range m.Formations {
			itor.FixNilFields()
		}

		if m.LockedObject == nil {
			m.LockedObject = &LockedObject{}
		}
		m.LockedObject.FixNilFields()

	}
}
func (m *FormationWear) Clone() *FormationWear {
	if m != nil {
		o := &FormationWear{}
		o.Pos = m.Pos
		if len(m.EquipIds) > 0 {
			o.EquipIds = make([]uint64, len(m.EquipIds))
			copy(o.EquipIds, m.EquipIds)
		}
		if len(m.MeridianIds) > 0 {
			o.MeridianIds = make([]uint64, len(m.MeridianIds))
			copy(o.MeridianIds, m.MeridianIds)
		}
		o.ThroneSupportUnlock = m.ThroneSupportUnlock
		o.SupportThrone = m.SupportThrone
		o.Refine = m.Refine.Clone()
		return o
	}
	return nil
}

func InitFormationWear() *FormationWear {
	m := &FormationWear{}
	m.FixNilFields()
	return m
}
func (m *FormationWear) FixNilFields() {
	if m != nil {

		if m.Refine == nil {
			m.Refine = &EquipRefine{}
		}
		m.Refine.FixNilFields()

	}
}
func (m *FormationGrow) Clone() *FormationGrow {
	if m != nil {
		o := &FormationGrow{}
		o.Pos = m.Pos
		o.Level = m.Level
		o.BodyStage = m.BodyStage
		o.BodyFull = m.BodyFull
		if len(m.LevelPassiveLevels) > 0 {
			o.LevelPassiveLevels = make([]uint32, len(m.LevelPassiveLevels))
			copy(o.LevelPassiveLevels, m.LevelPassiveLevels)
		}
		if len(m.BodyPassiveLevels) > 0 {
			o.BodyPassiveLevels = make([]uint32, len(m.BodyPassiveLevels))
			copy(o.BodyPassiveLevels, m.BodyPassiveLevels)
		}
		o.DegreeStage = m.DegreeStage
		o.HorcruxExp = m.HorcruxExp
		if len(m.DegreeSkills) > 0 {
			o.DegreeSkills = make(map[uint32]uint32, len(m.DegreeSkills))
			for k, e := range m.DegreeSkills {
				o.DegreeSkills[k] = e
			}
		}
		return o
	}
	return nil
}

func InitFormationGrow() *FormationGrow {
	m := &FormationGrow{}
	m.FixNilFields()
	return m
}
func (m *FormationGrow) FixNilFields() {
	if m != nil {

		if m.DegreeSkills == nil {
			m.DegreeSkills = make(map[uint32]uint32)
		}

	}
}
func (m *Formation) Clone() *Formation {
	if m != nil {
		o := &Formation{}
		o.Kid = m.Kid
		o.Pos = m.Pos
		o.BattlePos = m.BattlePos
		o.Power = m.Power
		o.Horcrux = m.Horcrux.Clone()
		return o
	}
	return nil
}

func InitFormation() *Formation {
	m := &Formation{}
	m.FixNilFields()
	return m
}
func (m *Formation) FixNilFields() {
	if m != nil {

		if m.Horcrux == nil {
			m.Horcrux = &FormationHorcrux{}
		}
		m.Horcrux.FixNilFields()

	}
}
func (m *LockedObject) Clone() *LockedObject {
	if m != nil {
		o := &LockedObject{}
		o.ResetTime = m.ResetTime
		if len(m.Knights) > 0 {
			o.Knights = make([]uint64, len(m.Knights))
			copy(o.Knights, m.Knights)
		}
		if len(m.Fashions) > 0 {
			o.Fashions = make([]uint32, len(m.Fashions))
			copy(o.Fashions, m.Fashions)
		}
		if len(m.SkillBooks) > 0 {
			o.SkillBooks = make([]uint32, len(m.SkillBooks))
			copy(o.SkillBooks, m.SkillBooks)
		}
		if len(m.Thrones) > 0 {
			o.Thrones = make([]uint32, len(m.Thrones))
			copy(o.Thrones, m.Thrones)
		}
		if len(m.Horcruxes) > 0 {
			o.Horcruxes = make([]uint64, len(m.Horcruxes))
			copy(o.Horcruxes, m.Horcruxes)
		}
		if len(m.Rules) > 0 {
			o.Rules = make([]uint32, len(m.Rules))
			copy(o.Rules, m.Rules)
		}
		if len(m.SupportFashions) > 0 {
			o.SupportFashions = make([]uint32, len(m.SupportFashions))
			copy(o.SupportFashions, m.SupportFashions)
		}
		if len(m.OperationThrone) > 0 {
			o.OperationThrone = make([]uint32, len(m.OperationThrone))
			copy(o.OperationThrone, m.OperationThrone)
		}
		return o
	}
	return nil
}

func InitLockedObject() *LockedObject {
	m := &LockedObject{}
	m.FixNilFields()
	return m
}
func (m *LockedObject) FixNilFields() {
	if m != nil {

	}
}
func (m *PetRiseData) Clone() *PetRiseData {
	if m != nil {
		o := &PetRiseData{}
		o.PetId = m.PetId
		if len(m.CostIds) > 0 {
			o.CostIds = make([]uint64, len(m.CostIds))
			copy(o.CostIds, m.CostIds)
		}
		return o
	}
	return nil
}

func InitPetRiseData() *PetRiseData {
	m := &PetRiseData{}
	m.FixNilFields()
	return m
}
func (m *PetRiseData) FixNilFields() {
	if m != nil {

	}
}
func (m *PetUpQuality) Clone() *PetUpQuality {
	if m != nil {
		o := &PetUpQuality{}
		o.PetId = m.PetId
		if len(m.CostIds) > 0 {
			o.CostIds = make([]uint64, len(m.CostIds))
			copy(o.CostIds, m.CostIds)
		}
		return o
	}
	return nil
}

func InitPetUpQuality() *PetUpQuality {
	m := &PetUpQuality{}
	m.FixNilFields()
	return m
}
func (m *PetUpQuality) FixNilFields() {
	if m != nil {

	}
}
func (m *LuckyChance) Clone() *LuckyChance {
	if m != nil {
		o := &LuckyChance{}
		o.Id = m.Id
		o.Etime = m.Etime
		o.BaseId = m.BaseId
		o.Param0 = m.Param0
		o.Param1 = m.Param1
		o.Stime = m.Stime
		return o
	}
	return nil
}

func InitLuckyChance() *LuckyChance {
	m := &LuckyChance{}
	m.FixNilFields()
	return m
}
func (m *LuckyChance) FixNilFields() {
	if m != nil {

	}
}
func (m *LuckyChanceInfo) Clone() *LuckyChanceInfo {
	if m != nil {
		o := &LuckyChanceInfo{}
		if len(m.Chances) > 0 {
			o.Chances = make([]*LuckyChance, len(m.Chances))
			for k, e := range m.Chances {
				o.Chances[k] = e.Clone()
			}
		}
		o.RishiChance = m.RishiChance.Clone()
		o.Tm = m.Tm
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitLuckyChanceInfo() *LuckyChanceInfo {
	m := &LuckyChanceInfo{}
	m.FixNilFields()
	return m
}
func (m *LuckyChanceInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Chances {
			itor.FixNilFields()
		}

		if m.RishiChance == nil {
			m.RishiChance = &RishiLucky{}
		}
		m.RishiChance.FixNilFields()

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *RishiLucky) Clone() *RishiLucky {
	if m != nil {
		o := &RishiLucky{}
		o.Progress = m.Progress
		o.AwardId = m.AwardId
		o.PreId = m.PreId
		if len(m.Records) > 0 {
			o.Records = make(map[uint32]uint32, len(m.Records))
			for k, e := range m.Records {
				o.Records[k] = e
			}
		}
		return o
	}
	return nil
}

func InitRishiLucky() *RishiLucky {
	m := &RishiLucky{}
	m.FixNilFields()
	return m
}
func (m *RishiLucky) FixNilFields() {
	if m != nil {

		if m.Records == nil {
			m.Records = make(map[uint32]uint32)
		}

	}
}
func (m *Business) Clone() *Business {
	if m != nil {
		o := &Business{}
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.Suc = m.Suc
		o.Ctime = m.Ctime
		return o
	}
	return nil
}

func InitBusiness() *Business {
	m := &Business{}
	m.FixNilFields()
	return m
}
func (m *Business) FixNilFields() {
	if m != nil {

	}
}
func (m *ResourceLog) Clone() *ResourceLog {
	if m != nil {
		o := &ResourceLog{}
		o.Time = m.Time
		o.LogId = m.LogId
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitResourceLog() *ResourceLog {
	m := &ResourceLog{}
	m.FixNilFields()
	return m
}
func (m *ResourceLog) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *MakeInfo) Clone() *MakeInfo {
	if m != nil {
		o := &MakeInfo{}
		o.Id = m.Id
		o.StartTime = m.StartTime
		o.Num = m.Num
		o.FinishNum = m.FinishNum
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.Logs) > 0 {
			o.Logs = make([]*ResourceLog, len(m.Logs))
			for k, e := range m.Logs {
				o.Logs[k] = e.Clone()
			}
		}
		o.Level = m.Level
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		o.High = m.High
		return o
	}
	return nil
}

func InitMakeInfo() *MakeInfo {
	m := &MakeInfo{}
	m.FixNilFields()
	return m
}
func (m *MakeInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		for _, itor := range m.Logs {
			itor.FixNilFields()
		}

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

	}
}
func (m *EquipRoom) Clone() *EquipRoom {
	if m != nil {
		o := &EquipRoom{}
		o.Level = m.Level
		if len(m.PaperIds) > 0 {
			o.PaperIds = make([]uint32, len(m.PaperIds))
			copy(o.PaperIds, m.PaperIds)
		}
		o.Make = m.Make.Clone()
		o.Exp = m.Exp
		o.DailyResetTime = m.DailyResetTime
		o.WeeklyMakeNum = m.WeeklyMakeNum
		o.ReceivedAward = m.ReceivedAward.Clone()
		o.WeeklyNextRefreshTime = m.WeeklyNextRefreshTime
		if len(m.PaperTime) > 0 {
			o.PaperTime = make(map[uint32]uint32, len(m.PaperTime))
			for k, e := range m.PaperTime {
				o.PaperTime[k] = e
			}
		}
		o.HistoryMakeNum = m.HistoryMakeNum
		if len(m.LevelAwardedIds) > 0 {
			o.LevelAwardedIds = make([]uint32, len(m.LevelAwardedIds))
			copy(o.LevelAwardedIds, m.LevelAwardedIds)
		}
		o.ResearchNum = m.ResearchNum
		o.AdvanceResearchedNum = m.AdvanceResearchedNum
		if len(m.PaperHighProb) > 0 {
			o.PaperHighProb = make(map[uint32]uint32, len(m.PaperHighProb))
			for k, e := range m.PaperHighProb {
				o.PaperHighProb[k] = e
			}
		}
		if len(m.PaperProb) > 0 {
			o.PaperProb = make(map[uint32]uint32, len(m.PaperProb))
			for k, e := range m.PaperProb {
				o.PaperProb[k] = e
			}
		}
		return o
	}
	return nil
}

func InitEquipRoom() *EquipRoom {
	m := &EquipRoom{}
	m.FixNilFields()
	return m
}
func (m *EquipRoom) FixNilFields() {
	if m != nil {

		if m.Make == nil {
			m.Make = &MakeInfo{}
		}
		m.Make.FixNilFields()

		if m.ReceivedAward == nil {
			m.ReceivedAward = &ReceivedAward{}
		}
		m.ReceivedAward.FixNilFields()

		if m.PaperTime == nil {
			m.PaperTime = make(map[uint32]uint32)
		}

		if m.PaperHighProb == nil {
			m.PaperHighProb = make(map[uint32]uint32)
		}

		if m.PaperProb == nil {
			m.PaperProb = make(map[uint32]uint32)
		}

	}
}
func (m *PillRoom) Clone() *PillRoom {
	if m != nil {
		o := &PillRoom{}
		o.Level = m.Level
		if len(m.PaperIds) > 0 {
			o.PaperIds = make([]uint32, len(m.PaperIds))
			copy(o.PaperIds, m.PaperIds)
		}
		o.Make = m.Make.Clone()
		o.Exp = m.Exp
		o.MakeCount = m.MakeCount
		o.DailyResetTime = m.DailyResetTime
		if len(m.PaperProb) > 0 {
			o.PaperProb = make(map[uint32]uint32, len(m.PaperProb))
			for k, e := range m.PaperProb {
				o.PaperProb[k] = e
			}
		}
		if len(m.CritProb) > 0 {
			o.CritProb = make(map[uint32]uint32, len(m.CritProb))
			for k, e := range m.CritProb {
				o.CritProb[k] = e
			}
		}
		o.WeeklyMakeNum = m.WeeklyMakeNum
		o.ReceivedAward = m.ReceivedAward.Clone()
		o.WeeklyNextRefreshTime = m.WeeklyNextRefreshTime
		o.ResearchNum = m.ResearchNum
		o.AdvanceResearchedNum = m.AdvanceResearchedNum
		return o
	}
	return nil
}

func InitPillRoom() *PillRoom {
	m := &PillRoom{}
	m.FixNilFields()
	return m
}
func (m *PillRoom) FixNilFields() {
	if m != nil {

		if m.Make == nil {
			m.Make = &MakeInfo{}
		}
		m.Make.FixNilFields()

		if m.PaperProb == nil {
			m.PaperProb = make(map[uint32]uint32)
		}

		if m.CritProb == nil {
			m.CritProb = make(map[uint32]uint32)
		}

		if m.ReceivedAward == nil {
			m.ReceivedAward = &ReceivedAward{}
		}
		m.ReceivedAward.FixNilFields()

	}
}
func (m *Equipment) Clone() *Equipment {
	if m != nil {
		o := &Equipment{}
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.Level = m.Level
		if len(m.ProAttrs) > 0 {
			o.ProAttrs = make([]uint32, len(m.ProAttrs))
			copy(o.ProAttrs, m.ProAttrs)
		}
		if len(m.AddAttrs) > 0 {
			o.AddAttrs = make([]uint32, len(m.AddAttrs))
			copy(o.AddAttrs, m.AddAttrs)
		}
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		if len(m.CastCosts) > 0 {
			o.CastCosts = make([]*Resource, len(m.CastCosts))
			for k, e := range m.CastCosts {
				o.CastCosts[k] = e.Clone()
			}
		}
		o.CastExp = m.CastExp
		o.CastLevel = m.CastLevel
		o.EnchantExp = m.EnchantExp
		o.EnchantLevel = m.EnchantLevel
		if len(m.EnchantCosts) > 0 {
			o.EnchantCosts = make([]*Resource, len(m.EnchantCosts))
			for k, e := range m.EnchantCosts {
				o.EnchantCosts[k] = e.Clone()
			}
		}
		if len(m.EnchantProAttrs) > 0 {
			o.EnchantProAttrs = make([]uint32, len(m.EnchantProAttrs))
			copy(o.EnchantProAttrs, m.EnchantProAttrs)
		}
		if len(m.SupportEquipments) > 0 {
			o.SupportEquipments = make([]uint64, len(m.SupportEquipments))
			copy(o.SupportEquipments, m.SupportEquipments)
		}
		return o
	}
	return nil
}

func InitEquipment() *Equipment {
	m := &Equipment{}
	m.FixNilFields()
	return m
}
func (m *Equipment) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

		for _, itor := range m.CastCosts {
			itor.FixNilFields()
		}

		for _, itor := range m.EnchantCosts {
			itor.FixNilFields()
		}

	}
}
func (m *EquipRefine) Clone() *EquipRefine {
	if m != nil {
		o := &EquipRefine{}
		o.Times = m.Times
		o.Locked = m.Locked
		if len(m.Entries) > 0 {
			o.Entries = make([]*EquipRefineEntry, len(m.Entries))
			for k, e := range m.Entries {
				o.Entries[k] = e.Clone()
			}
		}
		if len(m.Temporaries) > 0 {
			o.Temporaries = make([]*EquipRefineEntries, len(m.Temporaries))
			for k, e := range m.Temporaries {
				o.Temporaries[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitEquipRefine() *EquipRefine {
	m := &EquipRefine{}
	m.FixNilFields()
	return m
}
func (m *EquipRefine) FixNilFields() {
	if m != nil {

		for _, itor := range m.Entries {
			itor.FixNilFields()
		}

		for _, itor := range m.Temporaries {
			itor.FixNilFields()
		}

	}
}
func (m *EquipRefineEntries) Clone() *EquipRefineEntries {
	if m != nil {
		o := &EquipRefineEntries{}
		if len(m.Entries) > 0 {
			o.Entries = make([]*EquipRefineEntry, len(m.Entries))
			for k, e := range m.Entries {
				o.Entries[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitEquipRefineEntries() *EquipRefineEntries {
	m := &EquipRefineEntries{}
	m.FixNilFields()
	return m
}
func (m *EquipRefineEntries) FixNilFields() {
	if m != nil {

		for _, itor := range m.Entries {
			itor.FixNilFields()
		}

	}
}
func (m *EquipRefineEntry) Clone() *EquipRefineEntry {
	if m != nil {
		o := &EquipRefineEntry{}
		o.Id = m.Id
		o.AttrId = m.AttrId
		o.IsInit = m.IsInit
		return o
	}
	return nil
}

func InitEquipRefineEntry() *EquipRefineEntry {
	m := &EquipRefineEntry{}
	m.FixNilFields()
	return m
}
func (m *EquipRefineEntry) FixNilFields() {
	if m != nil {

	}
}
func (m *EquipRefineAssist) Clone() *EquipRefineAssist {
	if m != nil {
		o := &EquipRefineAssist{}
		o.ScoreAlert = m.ScoreAlert
		if len(m.Qualities) > 0 {
			o.Qualities = make([]uint32, len(m.Qualities))
			copy(o.Qualities, m.Qualities)
		}
		o.ExchangeAlert = m.ExchangeAlert
		return o
	}
	return nil
}

func InitEquipRefineAssist() *EquipRefineAssist {
	m := &EquipRefineAssist{}
	m.FixNilFields()
	return m
}
func (m *EquipRefineAssist) FixNilFields() {
	if m != nil {

	}
}
func (m *EquipRefineShare) Clone() *EquipRefineShare {
	if m != nil {
		o := &EquipRefineShare{}
		o.Pet = m.Pet.Clone()
		if len(m.CastLevels) > 0 {
			o.CastLevels = make([]uint32, len(m.CastLevels))
			copy(o.CastLevels, m.CastLevels)
		}
		if len(m.Entries) > 0 {
			o.Entries = make([]*EquipRefineEntry, len(m.Entries))
			for k, e := range m.Entries {
				o.Entries[k] = e.Clone()
			}
		}
		if len(m.SupportEquipments) > 0 {
			o.SupportEquipments = make([]*SupportEquipments, len(m.SupportEquipments))
			for k, e := range m.SupportEquipments {
				o.SupportEquipments[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitEquipRefineShare() *EquipRefineShare {
	m := &EquipRefineShare{}
	m.FixNilFields()
	return m
}
func (m *EquipRefineShare) FixNilFields() {
	if m != nil {

		if m.Pet == nil {
			m.Pet = &PetSnapshot{}
		}
		m.Pet.FixNilFields()

		for _, itor := range m.Entries {
			itor.FixNilFields()
		}

		for _, itor := range m.SupportEquipments {
			itor.FixNilFields()
		}

	}
}
func (m *SupportEquipments) Clone() *SupportEquipments {
	if m != nil {
		o := &SupportEquipments{}
		if len(m.Ids) > 0 {
			o.Ids = make([]uint32, len(m.Ids))
			copy(o.Ids, m.Ids)
		}
		if len(m.CastLevels) > 0 {
			o.CastLevels = make([]uint32, len(m.CastLevels))
			copy(o.CastLevels, m.CastLevels)
		}
		return o
	}
	return nil
}

func InitSupportEquipments() *SupportEquipments {
	m := &SupportEquipments{}
	m.FixNilFields()
	return m
}
func (m *SupportEquipments) FixNilFields() {
	if m != nil {

	}
}
func (m *HandBook) Clone() *HandBook {
	if m != nil {
		o := &HandBook{}
		if len(m.Books) > 0 {
			o.Books = make([]uint32, len(m.Books))
			copy(o.Books, m.Books)
		}
		o.Type = m.Type
		o.Level = m.Level
		o.Exp = m.Exp
		return o
	}
	return nil
}

func InitHandBook() *HandBook {
	m := &HandBook{}
	m.FixNilFields()
	return m
}
func (m *HandBook) FixNilFields() {
	if m != nil {

	}
}
func (m *Shop) Clone() *Shop {
	if m != nil {
		o := &Shop{}
		o.Type = m.Type
		o.Level = m.Level
		return o
	}
	return nil
}

func InitShop() *Shop {
	m := &Shop{}
	m.FixNilFields()
	return m
}
func (m *Shop) FixNilFields() {
	if m != nil {

	}
}
func (m *Throne) Clone() *Throne {
	if m != nil {
		o := &Throne{}
		o.Id = m.Id
		o.Level = m.Level
		o.Star = m.Star
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		if len(m.SkillLevel) > 0 {
			o.SkillLevel = make([]*SmallKV, len(m.SkillLevel))
			for k, e := range m.SkillLevel {
				o.SkillLevel[k] = e.Clone()
			}
		}
		if len(m.AttrLevel) > 0 {
			o.AttrLevel = make([]*SmallKV, len(m.AttrLevel))
			for k, e := range m.AttrLevel {
				o.AttrLevel[k] = e.Clone()
			}
		}
		o.Point = m.Point
		return o
	}
	return nil
}

func InitThrone() *Throne {
	m := &Throne{}
	m.FixNilFields()
	return m
}
func (m *Throne) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

		for _, itor := range m.SkillLevel {
			itor.FixNilFields()
		}

		for _, itor := range m.AttrLevel {
			itor.FixNilFields()
		}

	}
}
func (m *ThroneUpStarCost) Clone() *ThroneUpStarCost {
	if m != nil {
		o := &ThroneUpStarCost{}
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitThroneUpStarCost() *ThroneUpStarCost {
	m := &ThroneUpStarCost{}
	m.FixNilFields()
	return m
}
func (m *ThroneUpStarCost) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

	}
}
func (m *ThroneUpStarParam) Clone() *ThroneUpStarParam {
	if m != nil {
		o := &ThroneUpStarParam{}
		o.ThroneId = m.ThroneId
		if len(m.UpStarCosts) > 0 {
			o.UpStarCosts = make([]*ThroneUpStarCost, len(m.UpStarCosts))
			for k, e := range m.UpStarCosts {
				o.UpStarCosts[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitThroneUpStarParam() *ThroneUpStarParam {
	m := &ThroneUpStarParam{}
	m.FixNilFields()
	return m
}
func (m *ThroneUpStarParam) FixNilFields() {
	if m != nil {

		for _, itor := range m.UpStarCosts {
			itor.FixNilFields()
		}

	}
}
func (m *RoomRedInfo) Clone() *RoomRedInfo {
	if m != nil {
		o := &RoomRedInfo{}
		o.Level = m.Level
		o.Exp = m.Exp
		if len(m.Paper) > 0 {
			o.Paper = make([]uint32, len(m.Paper))
			copy(o.Paper, m.Paper)
		}
		return o
	}
	return nil
}

func InitRoomRedInfo() *RoomRedInfo {
	m := &RoomRedInfo{}
	m.FixNilFields()
	return m
}
func (m *RoomRedInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *Npc) Clone() *Npc {
	if m != nil {
		o := &Npc{}
		o.Id = m.Id
		o.Relation = m.Relation
		o.Affinity = m.Affinity
		o.BusId = m.BusId
		o.BusBaseId = m.BusBaseId
		if len(m.TaskId) > 0 {
			o.TaskId = make([]uint32, len(m.TaskId))
			copy(o.TaskId, m.TaskId)
		}
		if len(m.AssociateValues) > 0 {
			o.AssociateValues = make([]uint32, len(m.AssociateValues))
			copy(o.AssociateValues, m.AssociateValues)
		}
		return o
	}
	return nil
}

func InitNpc() *Npc {
	m := &Npc{}
	m.FixNilFields()
	return m
}
func (m *Npc) FixNilFields() {
	if m != nil {

	}
}
func (m *NpcTeam) Clone() *NpcTeam {
	if m != nil {
		o := &NpcTeam{}
		o.Id = m.Id
		o.GroupId = m.GroupId
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.StartTime = m.StartTime
		o.DropTimes = m.DropTimes
		o.TickTime = m.TickTime
		if len(m.Logs) > 0 {
			o.Logs = make([]*ResourceLog, len(m.Logs))
			for k, e := range m.Logs {
				o.Logs[k] = e.Clone()
			}
		}
		o.Senior = m.Senior
		if len(m.NpcIds) > 0 {
			o.NpcIds = make([]uint32, len(m.NpcIds))
			copy(o.NpcIds, m.NpcIds)
		}
		o.SkillId = m.SkillId
		if len(m.ExtAwards) > 0 {
			o.ExtAwards = make([]*Resource, len(m.ExtAwards))
			for k, e := range m.ExtAwards {
				o.ExtAwards[k] = e.Clone()
			}
		}
		if len(m.Displays) > 0 {
			o.Displays = make([]*Resource, len(m.Displays))
			for k, e := range m.Displays {
				o.Displays[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitNpcTeam() *NpcTeam {
	m := &NpcTeam{}
	m.FixNilFields()
	return m
}
func (m *NpcTeam) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		for _, itor := range m.Logs {
			itor.FixNilFields()
		}

		for _, itor := range m.ExtAwards {
			itor.FixNilFields()
		}

		for _, itor := range m.Displays {
			itor.FixNilFields()
		}

	}
}
func (m *NpcRoom) Clone() *NpcRoom {
	if m != nil {
		o := &NpcRoom{}
		o.Level = m.Level
		if len(m.Npcs) > 0 {
			o.Npcs = make(map[uint32]*Npc, len(m.Npcs))
			for k, e := range m.Npcs {
				o.Npcs[k] = e.Clone()
			}
		}
		if len(m.Teams) > 0 {
			o.Teams = make(map[uint32]*NpcTeam, len(m.Teams))
			for k, e := range m.Teams {
				o.Teams[k] = e.Clone()
			}
		}
		o.DailyZero = m.DailyZero
		o.TalkNum = m.TalkNum
		if len(m.DispatchedNum) > 0 {
			o.DispatchedNum = make(map[uint32]uint32, len(m.DispatchedNum))
			for k, e := range m.DispatchedNum {
				o.DispatchedNum[k] = e
			}
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitNpcRoom() *NpcRoom {
	m := &NpcRoom{}
	m.FixNilFields()
	return m
}
func (m *NpcRoom) FixNilFields() {
	if m != nil {

		if m.Npcs == nil {
			m.Npcs = make(map[uint32]*Npc)
		}
		for _, itor := range m.Npcs {
			itor.FixNilFields()
		}

		if m.Teams == nil {
			m.Teams = make(map[uint32]*NpcTeam)
		}
		for _, itor := range m.Teams {
			itor.FixNilFields()
		}

		if m.DispatchedNum == nil {
			m.DispatchedNum = make(map[uint32]uint32)
		}

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *FairylandInfo) Clone() *FairylandInfo {
	if m != nil {
		o := &FairylandInfo{}
		o.TopStage = m.TopStage
		o.CurStage = m.CurStage
		o.ResetTimes = m.ResetTimes
		o.RebornTimes = m.RebornTimes
		o.WildcardTimes = m.WildcardTimes
		if len(m.Fairylands) > 0 {
			o.Fairylands = make(map[uint32]*Fairyland, len(m.Fairylands))
			for k, e := range m.Fairylands {
				o.Fairylands[k] = e.Clone()
			}
		}
		if len(m.Merchants) > 0 {
			o.Merchants = make(map[uint32]*FairyCell, len(m.Merchants))
			for k, e := range m.Merchants {
				o.Merchants[k] = e.Clone()
			}
		}
		o.StageAwards = m.StageAwards.Clone()
		return o
	}
	return nil
}

func InitFairylandInfo() *FairylandInfo {
	m := &FairylandInfo{}
	m.FixNilFields()
	return m
}
func (m *FairylandInfo) FixNilFields() {
	if m != nil {

		if m.Fairylands == nil {
			m.Fairylands = make(map[uint32]*Fairyland)
		}
		for _, itor := range m.Fairylands {
			itor.FixNilFields()
		}

		if m.Merchants == nil {
			m.Merchants = make(map[uint32]*FairyCell)
		}
		for _, itor := range m.Merchants {
			itor.FixNilFields()
		}

		if m.StageAwards == nil {
			m.StageAwards = &ReceivedAward{}
		}
		m.StageAwards.FixNilFields()

	}
}
func (m *Fairyland) Clone() *Fairyland {
	if m != nil {
		o := &Fairyland{}
		o.TopId = m.TopId
		o.AssistTimes = m.AssistTimes
		o.VictoryTimes = m.VictoryTimes
		o.DefeatedTimes = m.DefeatedTimes
		o.BuyedRebornTimes = m.BuyedRebornTimes
		o.RunedRebornTimes = m.RunedRebornTimes
		o.Floor = m.Floor.Clone()
		if len(m.AssistedPets) > 0 {
			o.AssistedPets = make([]uint64, len(m.AssistedPets))
			copy(o.AssistedPets, m.AssistedPets)
		}
		if len(m.ChoicedSkills) > 0 {
			o.ChoicedSkills = make([]uint32, len(m.ChoicedSkills))
			copy(o.ChoicedSkills, m.ChoicedSkills)
		}
		if len(m.ChallengedEnemys) > 0 {
			o.ChallengedEnemys = make([]uint64, len(m.ChallengedEnemys))
			copy(o.ChallengedEnemys, m.ChallengedEnemys)
		}
		if len(m.SummaryAwards) > 0 {
			o.SummaryAwards = make([]*Resource, len(m.SummaryAwards))
			for k, e := range m.SummaryAwards {
				o.SummaryAwards[k] = e.Clone()
			}
		}
		o.SummaryRebornTimes = m.SummaryRebornTimes
		o.SummaryWildcardTimes = m.SummaryWildcardTimes
		o.CurCellRebornTimes = m.CurCellRebornTimes
		return o
	}
	return nil
}

func InitFairyland() *Fairyland {
	m := &Fairyland{}
	m.FixNilFields()
	return m
}
func (m *Fairyland) FixNilFields() {
	if m != nil {

		if m.Floor == nil {
			m.Floor = &FairyFloor{}
		}
		m.Floor.FixNilFields()

		for _, itor := range m.SummaryAwards {
			itor.FixNilFields()
		}

	}
}
func (m *FairyFloor) Clone() *FairyFloor {
	if m != nil {
		o := &FairyFloor{}
		o.CurrentId = m.CurrentId
		o.ChoicedId = m.ChoicedId
		if len(m.MapData) > 0 {
			o.MapData = make(map[uint32]uint32, len(m.MapData))
			for k, e := range m.MapData {
				o.MapData[k] = e
			}
		}
		if len(m.PassingCells) > 0 {
			o.PassingCells = make([]uint32, len(m.PassingCells))
			copy(o.PassingCells, m.PassingCells)
		}
		if len(m.NextRowCells) > 0 {
			o.NextRowCells = make([]*FairyCell, len(m.NextRowCells))
			for k, e := range m.NextRowCells {
				o.NextRowCells[k] = e.Clone()
			}
		}
		if len(m.PreviewCells) > 0 {
			o.PreviewCells = make([]*FairyCell, len(m.PreviewCells))
			for k, e := range m.PreviewCells {
				o.PreviewCells[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitFairyFloor() *FairyFloor {
	m := &FairyFloor{}
	m.FixNilFields()
	return m
}
func (m *FairyFloor) FixNilFields() {
	if m != nil {

		if m.MapData == nil {
			m.MapData = make(map[uint32]uint32)
		}

		for _, itor := range m.NextRowCells {
			itor.FixNilFields()
		}

		for _, itor := range m.PreviewCells {
			itor.FixNilFields()
		}

	}
}
func (m *FairyCell) Clone() *FairyCell {
	if m != nil {
		o := &FairyCell{}
		o.Id = m.Id
		o.GroupId = m.GroupId
		o.Enemy = m.Enemy.Clone()
		o.MonsterTeamId = m.MonsterTeamId
		if len(m.EnemyHps) > 0 {
			o.EnemyHps = make([]*Pair, len(m.EnemyHps))
			for k, e := range m.EnemyHps {
				o.EnemyHps[k] = e.Clone()
			}
		}
		if len(m.DivineSkills) > 0 {
			o.DivineSkills = make([]uint32, len(m.DivineSkills))
			copy(o.DivineSkills, m.DivineSkills)
		}
		if len(m.MerchantGoods) > 0 {
			o.MerchantGoods = make([]*Goods, len(m.MerchantGoods))
			for k, e := range m.MerchantGoods {
				o.MerchantGoods[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitFairyCell() *FairyCell {
	m := &FairyCell{}
	m.FixNilFields()
	return m
}
func (m *FairyCell) FixNilFields() {
	if m != nil {

		if m.Enemy == nil {
			m.Enemy = &UserSnapshot{}
		}
		m.Enemy.FixNilFields()

		for _, itor := range m.EnemyHps {
			itor.FixNilFields()
		}

		for _, itor := range m.MerchantGoods {
			itor.FixNilFields()
		}

	}
}
func (m *HelpUnit) Clone() *HelpUnit {
	if m != nil {
		o := &HelpUnit{}
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.Power = m.Power
		o.OwnerId = m.OwnerId
		o.OwnerName = m.OwnerName
		o.OwnerBaseId = m.OwnerBaseId
		o.Level = m.Level
		return o
	}
	return nil
}

func InitHelpUnit() *HelpUnit {
	m := &HelpUnit{}
	m.FixNilFields()
	return m
}
func (m *HelpUnit) FixNilFields() {
	if m != nil {

	}
}
func (m *WorldChapter) Clone() *WorldChapter {
	if m != nil {
		o := &WorldChapter{}
		o.Id = m.Id
		o.Row = m.Row
		o.Col = m.Col
		o.DailyZero = m.DailyZero
		o.Progress = m.Progress
		o.BossKilled = m.BossKilled
		o.Weather = m.Weather
		o.LocalWeatherEndTm = m.LocalWeatherEndTm
		o.LastFinishedEvt = m.LastFinishedEvt
		o.LastTransferEvent = m.LastTransferEvent
		if len(m.EvtOrder) > 0 {
			o.EvtOrder = make([]int32, len(m.EvtOrder))
			copy(o.EvtOrder, m.EvtOrder)
		}
		if len(m.FollowEvts) > 0 {
			o.FollowEvts = make([]uint32, len(m.FollowEvts))
			copy(o.FollowEvts, m.FollowEvts)
		}
		if len(m.FinishedEvts) > 0 {
			o.FinishedEvts = make([]uint32, len(m.FinishedEvts))
			copy(o.FinishedEvts, m.FinishedEvts)
		}
		if len(m.FinishedEvtGroups) > 0 {
			o.FinishedEvtGroups = make([]uint32, len(m.FinishedEvtGroups))
			copy(o.FinishedEvtGroups, m.FinishedEvtGroups)
		}
		if len(m.RelyTasks) > 0 {
			o.RelyTasks = make([]uint32, len(m.RelyTasks))
			copy(o.RelyTasks, m.RelyTasks)
		}
		if len(m.Altars) > 0 {
			o.Altars = make([]*WorldChapterAltar, len(m.Altars))
			for k, e := range m.Altars {
				o.Altars[k] = e.Clone()
			}
		}
		if len(m.Tasks) > 0 {
			o.Tasks = make([]*WorldTask, len(m.Tasks))
			for k, e := range m.Tasks {
				o.Tasks[k] = e.Clone()
			}
		}
		if len(m.RewardMonsters) > 0 {
			o.RewardMonsters = make([]*WorldRewardMonster, len(m.RewardMonsters))
			for k, e := range m.RewardMonsters {
				o.RewardMonsters[k] = e.Clone()
			}
		}
		if len(m.NpcPledges) > 0 {
			o.NpcPledges = make([]*WorldNpcPledge, len(m.NpcPledges))
			for k, e := range m.NpcPledges {
				o.NpcPledges[k] = e.Clone()
			}
		}
		if len(m.Business) > 0 {
			o.Business = make([]*WorldBusiness, len(m.Business))
			for k, e := range m.Business {
				o.Business[k] = e.Clone()
			}
		}
		if len(m.MythicalBoss) > 0 {
			o.MythicalBoss = make([]*WorldMythicalBoss, len(m.MythicalBoss))
			for k, e := range m.MythicalBoss {
				o.MythicalBoss[k] = e.Clone()
			}
		}
		if len(m.Budo) > 0 {
			o.Budo = make([]*WorldBudo, len(m.Budo))
			for k, e := range m.Budo {
				o.Budo[k] = e.Clone()
			}
		}
		if len(m.Collects) > 0 {
			o.Collects = make([]*WorldCollectItems, len(m.Collects))
			for k, e := range m.Collects {
				o.Collects[k] = e.Clone()
			}
		}
		if len(m.Exchanges) > 0 {
			o.Exchanges = make([]*WorldExchangeItem, len(m.Exchanges))
			for k, e := range m.Exchanges {
				o.Exchanges[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitWorldChapter() *WorldChapter {
	m := &WorldChapter{}
	m.FixNilFields()
	return m
}
func (m *WorldChapter) FixNilFields() {
	if m != nil {

		for _, itor := range m.Altars {
			itor.FixNilFields()
		}

		for _, itor := range m.Tasks {
			itor.FixNilFields()
		}

		for _, itor := range m.RewardMonsters {
			itor.FixNilFields()
		}

		for _, itor := range m.NpcPledges {
			itor.FixNilFields()
		}

		for _, itor := range m.Business {
			itor.FixNilFields()
		}

		for _, itor := range m.MythicalBoss {
			itor.FixNilFields()
		}

		for _, itor := range m.Budo {
			itor.FixNilFields()
		}

		for _, itor := range m.Collects {
			itor.FixNilFields()
		}

		for _, itor := range m.Exchanges {
			itor.FixNilFields()
		}

	}
}
func (m *WorldCollectItems) Clone() *WorldCollectItems {
	if m != nil {
		o := &WorldCollectItems{}
		o.EventId = m.EventId
		if len(m.ItemId) > 0 {
			o.ItemId = make([]uint32, len(m.ItemId))
			copy(o.ItemId, m.ItemId)
		}
		return o
	}
	return nil
}

func InitWorldCollectItems() *WorldCollectItems {
	m := &WorldCollectItems{}
	m.FixNilFields()
	return m
}
func (m *WorldCollectItems) FixNilFields() {
	if m != nil {

	}
}
func (m *WorldBudo) Clone() *WorldBudo {
	if m != nil {
		o := &WorldBudo{}
		o.Evt = m.Evt
		if len(m.Appoints) > 0 {
			o.Appoints = make([]uint32, len(m.Appoints))
			copy(o.Appoints, m.Appoints)
		}
		if len(m.Selected) > 0 {
			o.Selected = make([]uint32, len(m.Selected))
			copy(o.Selected, m.Selected)
		}
		return o
	}
	return nil
}

func InitWorldBudo() *WorldBudo {
	m := &WorldBudo{}
	m.FixNilFields()
	return m
}
func (m *WorldBudo) FixNilFields() {
	if m != nil {

	}
}
func (m *WorldMythicalBoss) Clone() *WorldMythicalBoss {
	if m != nil {
		o := &WorldMythicalBoss{}
		o.Evt = m.Evt
		if len(m.Awards) > 0 {
			o.Awards = make([]uint32, len(m.Awards))
			copy(o.Awards, m.Awards)
		}
		return o
	}
	return nil
}

func InitWorldMythicalBoss() *WorldMythicalBoss {
	m := &WorldMythicalBoss{}
	m.FixNilFields()
	return m
}
func (m *WorldMythicalBoss) FixNilFields() {
	if m != nil {

	}
}
func (m *WorldChapterAltar) Clone() *WorldChapterAltar {
	if m != nil {
		o := &WorldChapterAltar{}
		o.EventId = m.EventId
		o.Buff = m.Buff
		o.EndTm = m.EndTm
		o.BuyedCnt = m.BuyedCnt
		o.BuyedTm = m.BuyedTm
		return o
	}
	return nil
}

func InitWorldChapterAltar() *WorldChapterAltar {
	m := &WorldChapterAltar{}
	m.FixNilFields()
	return m
}
func (m *WorldChapterAltar) FixNilFields() {
	if m != nil {

	}
}
func (m *WorldBusiness) Clone() *WorldBusiness {
	if m != nil {
		o := &WorldBusiness{}
		o.EventId = m.EventId
		o.BusId = m.BusId
		o.BusBaseId = m.BusBaseId
		return o
	}
	return nil
}

func InitWorldBusiness() *WorldBusiness {
	m := &WorldBusiness{}
	m.FixNilFields()
	return m
}
func (m *WorldBusiness) FixNilFields() {
	if m != nil {

	}
}
func (m *WorldTask) Clone() *WorldTask {
	if m != nil {
		o := &WorldTask{}
		o.Id = m.Id
		if len(m.FinishedEvts) > 0 {
			o.FinishedEvts = make([]uint32, len(m.FinishedEvts))
			copy(o.FinishedEvts, m.FinishedEvts)
		}
		o.Finished = m.Finished
		return o
	}
	return nil
}

func InitWorldTask() *WorldTask {
	m := &WorldTask{}
	m.FixNilFields()
	return m
}
func (m *WorldTask) FixNilFields() {
	if m != nil {

	}
}
func (m *WorldRewardMonster) Clone() *WorldRewardMonster {
	if m != nil {
		o := &WorldRewardMonster{}
		o.Id = m.Id
		o.Row = m.Row
		o.Col = m.Col
		o.EndTm = m.EndTm
		o.DisturbCnt = m.DisturbCnt
		return o
	}
	return nil
}

func InitWorldRewardMonster() *WorldRewardMonster {
	m := &WorldRewardMonster{}
	m.FixNilFields()
	return m
}
func (m *WorldRewardMonster) FixNilFields() {
	if m != nil {

	}
}
func (m *WorldNpcPledge) Clone() *WorldNpcPledge {
	if m != nil {
		o := &WorldNpcPledge{}
		o.EventId = m.EventId
		o.Row = m.Row
		o.Col = m.Col
		return o
	}
	return nil
}

func InitWorldNpcPledge() *WorldNpcPledge {
	m := &WorldNpcPledge{}
	m.FixNilFields()
	return m
}
func (m *WorldNpcPledge) FixNilFields() {
	if m != nil {

	}
}
func (m *WorldExchangeItem) Clone() *WorldExchangeItem {
	if m != nil {
		o := &WorldExchangeItem{}
		o.EventId = m.EventId
		o.State = m.State
		return o
	}
	return nil
}

func InitWorldExchangeItem() *WorldExchangeItem {
	m := &WorldExchangeItem{}
	m.FixNilFields()
	return m
}
func (m *WorldExchangeItem) FixNilFields() {
	if m != nil {

	}
}
func (m *HideChapterGroup) Clone() *HideChapterGroup {
	if m != nil {
		o := &HideChapterGroup{}
		o.Group = m.Group
		o.DailyFinishedCnt = m.DailyFinishedCnt
		o.FinishedChapterId = m.FinishedChapterId
		o.FinishedTime = m.FinishedTime
		return o
	}
	return nil
}

func InitHideChapterGroup() *HideChapterGroup {
	m := &HideChapterGroup{}
	m.FixNilFields()
	return m
}
func (m *HideChapterGroup) FixNilFields() {
	if m != nil {

	}
}
func (m *ArenaPos) Clone() *ArenaPos {
	if m != nil {
		o := &ArenaPos{}
		o.Pos = m.Pos
		o.Words = m.Words
		o.User = m.User.Clone()
		return o
	}
	return nil
}

func InitArenaPos() *ArenaPos {
	m := &ArenaPos{}
	m.FixNilFields()
	return m
}
func (m *ArenaPos) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *ArenaGroup) Clone() *ArenaGroup {
	if m != nil {
		o := &ArenaGroup{}
		o.GroupId = m.GroupId
		if len(m.Poss) > 0 {
			o.Poss = make([]*ArenaPos, len(m.Poss))
			for k, e := range m.Poss {
				o.Poss[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitArenaGroup() *ArenaGroup {
	m := &ArenaGroup{}
	m.FixNilFields()
	return m
}
func (m *ArenaGroup) FixNilFields() {
	if m != nil {

		for _, itor := range m.Poss {
			itor.FixNilFields()
		}

	}
}
func (m *Arena) Clone() *Arena {
	if m != nil {
		o := &Arena{}
		o.GroupRank = m.GroupRank.Clone()
		o.ChallengeNum = m.ChallengeNum
		o.BarrierIndex = m.BarrierIndex
		o.MaxPos = m.MaxPos
		o.CurPos = m.CurPos
		return o
	}
	return nil
}

func InitArena() *Arena {
	m := &Arena{}
	m.FixNilFields()
	return m
}
func (m *Arena) FixNilFields() {
	if m != nil {

		if m.GroupRank == nil {
			m.GroupRank = &ArenaGroup{}
		}
		m.GroupRank.FixNilFields()

	}
}
func (m *FactionTask) Clone() *FactionTask {
	if m != nil {
		o := &FactionTask{}
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.EndTm = m.EndTm
		o.AwardState = m.AwardState
		o.CreateTm = m.CreateTm
		if len(m.Knights) > 0 {
			o.Knights = make([]uint64, len(m.Knights))
			copy(o.Knights, m.Knights)
		}
		o.DispatchType = m.DispatchType
		return o
	}
	return nil
}

func InitFactionTask() *FactionTask {
	m := &FactionTask{}
	m.FixNilFields()
	return m
}
func (m *FactionTask) FixNilFields() {
	if m != nil {

	}
}
func (m *Faction) Clone() *Faction {
	if m != nil {
		o := &Faction{}
		o.Id = m.Id
		o.Grade = m.Grade
		o.Prestige = m.Prestige
		o.Year = m.Year
		o.JoinTm = m.JoinTm
		o.Treasures = m.Treasures
		o.Motto = m.Motto
		o.Progress = m.Progress
		o.AchieveChoice = m.AchieveChoice
		return o
	}
	return nil
}

func InitFaction() *Faction {
	m := &Faction{}
	m.FixNilFields()
	return m
}
func (m *Faction) FixNilFields() {
	if m != nil {

	}
}
func (m *FactionCommon) Clone() *FactionCommon {
	if m != nil {
		o := &FactionCommon{}
		o.UserId = m.UserId
		if len(m.Tasks) > 0 {
			o.Tasks = make([]*FactionTask, len(m.Tasks))
			for k, e := range m.Tasks {
				o.Tasks[k] = e.Clone()
			}
		}
		o.UpdateTasksTm = m.UpdateTasksTm
		o.Credit = m.Credit
		o.CreditAwardedId = m.CreditAwardedId
		if len(m.ProgressAwardedIds) > 0 {
			o.ProgressAwardedIds = make([]uint32, len(m.ProgressAwardedIds))
			copy(o.ProgressAwardedIds, m.ProgressAwardedIds)
		}
		o.KungfuGrade = m.KungfuGrade
		o.KungfuExp = m.KungfuExp
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.KfaConditions) > 0 {
			o.KfaConditions = make(map[uint32]*Condition, len(m.KfaConditions))
			for k, e := range m.KfaConditions {
				o.KfaConditions[k] = e.Clone()
			}
		}
		o.KfaReceivedAward = m.KfaReceivedAward.Clone()
		return o
	}
	return nil
}

func InitFactionCommon() *FactionCommon {
	m := &FactionCommon{}
	m.FixNilFields()
	return m
}
func (m *FactionCommon) FixNilFields() {
	if m != nil {

		for _, itor := range m.Tasks {
			itor.FixNilFields()
		}

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

		if m.KfaConditions == nil {
			m.KfaConditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.KfaConditions {
			itor.FixNilFields()
		}

		if m.KfaReceivedAward == nil {
			m.KfaReceivedAward = &ReceivedAward{}
		}
		m.KfaReceivedAward.FixNilFields()

	}
}
func (m *FacContestChallenge) Clone() *FacContestChallenge {
	if m != nil {
		o := &FacContestChallenge{}
		o.Star = m.Star
		if len(m.Appoints) > 0 {
			o.Appoints = make([]uint32, len(m.Appoints))
			copy(o.Appoints, m.Appoints)
		}
		if len(m.Selected) > 0 {
			o.Selected = make([]uint32, len(m.Selected))
			copy(o.Selected, m.Selected)
		}
		o.CurrentFloor = m.CurrentFloor
		o.FailCnt = m.FailCnt
		o.OldStar = m.OldStar
		return o
	}
	return nil
}

func InitFacContestChallenge() *FacContestChallenge {
	m := &FacContestChallenge{}
	m.FixNilFields()
	return m
}
func (m *FacContestChallenge) FixNilFields() {
	if m != nil {

	}
}
func (m *FacContestTodayBestChallenge) Clone() *FacContestTodayBestChallenge {
	if m != nil {
		o := &FacContestTodayBestChallenge{}
		o.TodayZero = m.TodayZero
		o.Stage = m.Stage
		o.Star = m.Star
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.BattleCnt = m.BattleCnt
		if len(m.DropIds) > 0 {
			o.DropIds = make([]uint32, len(m.DropIds))
			copy(o.DropIds, m.DropIds)
		}
		o.Floor = m.Floor
		return o
	}
	return nil
}

func InitFacContestTodayBestChallenge() *FacContestTodayBestChallenge {
	m := &FacContestTodayBestChallenge{}
	m.FixNilFields()
	return m
}
func (m *FacContestTodayBestChallenge) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *FacContestStage) Clone() *FacContestStage {
	if m != nil {
		o := &FacContestStage{}
		o.Stage = m.Stage
		o.MaxStar = m.MaxStar
		o.Challenge = m.Challenge.Clone()
		o.MaxFloor = m.MaxFloor
		o.TodayBest = m.TodayBest.Clone()
		if len(m.PeakStar) > 0 {
			o.PeakStar = make(map[uint32]uint32, len(m.PeakStar))
			for k, e := range m.PeakStar {
				o.PeakStar[k] = e
			}
		}
		if len(m.QuickAppointFloors) > 0 {
			o.QuickAppointFloors = make([]uint32, len(m.QuickAppointFloors))
			copy(o.QuickAppointFloors, m.QuickAppointFloors)
		}
		o.StageAward = m.StageAward
		return o
	}
	return nil
}

func InitFacContestStage() *FacContestStage {
	m := &FacContestStage{}
	m.FixNilFields()
	return m
}
func (m *FacContestStage) FixNilFields() {
	if m != nil {

		if m.Challenge == nil {
			m.Challenge = &FacContestChallenge{}
		}
		m.Challenge.FixNilFields()

		if m.TodayBest == nil {
			m.TodayBest = &FacContestTodayBestChallenge{}
		}
		m.TodayBest.FixNilFields()

		if m.PeakStar == nil {
			m.PeakStar = make(map[uint32]uint32)
		}

	}
}
func (m *FacContestChallengeResult) Clone() *FacContestChallengeResult {
	if m != nil {
		o := &FacContestChallengeResult{}
		o.Stage = m.Stage
		o.Star = m.Star
		o.Floor = m.Floor
		o.Win = m.Win
		if len(m.SummaryAwards) > 0 {
			o.SummaryAwards = make([]*Resource, len(m.SummaryAwards))
			for k, e := range m.SummaryAwards {
				o.SummaryAwards[k] = e.Clone()
			}
		}
		o.OldStar = m.OldStar
		return o
	}
	return nil
}

func InitFacContestChallengeResult() *FacContestChallengeResult {
	m := &FacContestChallengeResult{}
	m.FixNilFields()
	return m
}
func (m *FacContestChallengeResult) FixNilFields() {
	if m != nil {

		for _, itor := range m.SummaryAwards {
			itor.FixNilFields()
		}

	}
}
func (m *FacContest) Clone() *FacContest {
	if m != nil {
		o := &FacContest{}
		o.ChallengeNum = m.ChallengeNum
		o.AwardStage = m.AwardStage.Clone()
		if len(m.Stages) > 0 {
			o.Stages = make([]*FacContestStage, len(m.Stages))
			for k, e := range m.Stages {
				o.Stages[k] = e.Clone()
			}
		}
		o.LastAttendStage = m.LastAttendStage
		o.StarData = m.StarData.Clone()
		return o
	}
	return nil
}

func InitFacContest() *FacContest {
	m := &FacContest{}
	m.FixNilFields()
	return m
}
func (m *FacContest) FixNilFields() {
	if m != nil {

		if m.AwardStage == nil {
			m.AwardStage = &FacContestChallengeResult{}
		}
		m.AwardStage.FixNilFields()

		for _, itor := range m.Stages {
			itor.FixNilFields()
		}

		if m.StarData == nil {
			m.StarData = &FacContestStar{}
		}
		m.StarData.FixNilFields()

	}
}
func (m *FacContestStar) Clone() *FacContestStar {
	if m != nil {
		o := &FacContestStar{}
		o.Star = m.Star
		o.ReceivedAward = m.ReceivedAward.Clone()
		return o
	}
	return nil
}

func InitFacContestStar() *FacContestStar {
	m := &FacContestStar{}
	m.FixNilFields()
	return m
}
func (m *FacContestStar) FixNilFields() {
	if m != nil {

		if m.ReceivedAward == nil {
			m.ReceivedAward = &ReceivedAward{}
		}
		m.ReceivedAward.FixNilFields()

	}
}
func (m *HallOfFame) Clone() *HallOfFame {
	if m != nil {
		o := &HallOfFame{}
		o.Uid = m.Uid
		o.LikedCnt = m.LikedCnt
		o.Motto = m.Motto
		return o
	}
	return nil
}

func InitHallOfFame() *HallOfFame {
	m := &HallOfFame{}
	m.FixNilFields()
	return m
}
func (m *HallOfFame) FixNilFields() {
	if m != nil {

	}
}
func (m *AchieveTask) Clone() *AchieveTask {
	if m != nil {
		o := &AchieveTask{}
		o.Id = m.Id
		o.Progress = m.Progress
		o.Awarded = m.Awarded
		o.Finished = m.Finished
		o.Tm = m.Tm
		o.Choice = m.Choice
		return o
	}
	return nil
}

func InitAchieveTask() *AchieveTask {
	m := &AchieveTask{}
	m.FixNilFields()
	return m
}
func (m *AchieveTask) FixNilFields() {
	if m != nil {

	}
}
func (m *AchieveTitle) Clone() *AchieveTitle {
	if m != nil {
		o := &AchieveTitle{}
		o.Id = m.Id
		o.Tm = m.Tm
		o.Choice = m.Choice
		return o
	}
	return nil
}

func InitAchieveTitle() *AchieveTitle {
	m := &AchieveTitle{}
	m.FixNilFields()
	return m
}
func (m *AchieveTitle) FixNilFields() {
	if m != nil {

	}
}
func (m *AchieveTaskGroup) Clone() *AchieveTaskGroup {
	if m != nil {
		o := &AchieveTaskGroup{}
		o.GroupId = m.GroupId
		o.Progress = m.Progress
		o.MaxId = m.MaxId
		o.RewardId = m.RewardId
		return o
	}
	return nil
}

func InitAchieveTaskGroup() *AchieveTaskGroup {
	m := &AchieveTaskGroup{}
	m.FixNilFields()
	return m
}
func (m *AchieveTaskGroup) FixNilFields() {
	if m != nil {

	}
}
func (m *AchieveInfo) Clone() *AchieveInfo {
	if m != nil {
		o := &AchieveInfo{}
		if len(m.Feelings) > 0 {
			o.Feelings = make(map[uint32]*AchieveTask, len(m.Feelings))
			for k, e := range m.Feelings {
				o.Feelings[k] = e.Clone()
			}
		}
		if len(m.Titles) > 0 {
			o.Titles = make(map[uint32]*AchieveTitle, len(m.Titles))
			for k, e := range m.Titles {
				o.Titles[k] = e.Clone()
			}
		}
		o.Exp = m.Exp
		o.Level = m.Level
		if len(m.LevelAwarded) > 0 {
			o.LevelAwarded = make(map[uint32]bool, len(m.LevelAwarded))
			for k, e := range m.LevelAwarded {
				o.LevelAwarded[k] = e
			}
		}
		if len(m.AchieveTaskGroups) > 0 {
			o.AchieveTaskGroups = make(map[uint32]*AchieveTaskGroup, len(m.AchieveTaskGroups))
			for k, e := range m.AchieveTaskGroups {
				o.AchieveTaskGroups[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitAchieveInfo() *AchieveInfo {
	m := &AchieveInfo{}
	m.FixNilFields()
	return m
}
func (m *AchieveInfo) FixNilFields() {
	if m != nil {

		if m.Feelings == nil {
			m.Feelings = make(map[uint32]*AchieveTask)
		}
		for _, itor := range m.Feelings {
			itor.FixNilFields()
		}

		if m.Titles == nil {
			m.Titles = make(map[uint32]*AchieveTitle)
		}
		for _, itor := range m.Titles {
			itor.FixNilFields()
		}

		if m.LevelAwarded == nil {
			m.LevelAwarded = make(map[uint32]bool)
		}

		if m.AchieveTaskGroups == nil {
			m.AchieveTaskGroups = make(map[uint32]*AchieveTaskGroup)
		}
		for _, itor := range m.AchieveTaskGroups {
			itor.FixNilFields()
		}

	}
}
func (m *DailyTaskInfo) Clone() *DailyTaskInfo {
	if m != nil {
		o := &DailyTaskInfo{}
		o.Level = m.Level
		if len(m.Tasks) > 0 {
			o.Tasks = make(map[uint32]*AchieveTask, len(m.Tasks))
			for k, e := range m.Tasks {
				o.Tasks[k] = e.Clone()
			}
		}
		o.Score = m.Score
		if len(m.ScoreAwarded) > 0 {
			o.ScoreAwarded = make(map[uint32]bool, len(m.ScoreAwarded))
			for k, e := range m.ScoreAwarded {
				o.ScoreAwarded[k] = e
			}
		}
		o.DailyZero = m.DailyZero
		o.Soar = m.Soar
		return o
	}
	return nil
}

func InitDailyTaskInfo() *DailyTaskInfo {
	m := &DailyTaskInfo{}
	m.FixNilFields()
	return m
}
func (m *DailyTaskInfo) FixNilFields() {
	if m != nil {

		if m.Tasks == nil {
			m.Tasks = make(map[uint32]*AchieveTask)
		}
		for _, itor := range m.Tasks {
			itor.FixNilFields()
		}

		if m.ScoreAwarded == nil {
			m.ScoreAwarded = make(map[uint32]bool)
		}

	}
}
func (m *WeeklyTaskInfo) Clone() *WeeklyTaskInfo {
	if m != nil {
		o := &WeeklyTaskInfo{}
		o.WeeklyZero = m.WeeklyZero
		o.Level = m.Level
		o.Score = m.Score
		if len(m.ScoreAwarded) > 0 {
			o.ScoreAwarded = make(map[uint32]bool, len(m.ScoreAwarded))
			for k, e := range m.ScoreAwarded {
				o.ScoreAwarded[k] = e
			}
		}
		if len(m.AchieveTaskGroups) > 0 {
			o.AchieveTaskGroups = make(map[uint32]*AchieveTaskGroup, len(m.AchieveTaskGroups))
			for k, e := range m.AchieveTaskGroups {
				o.AchieveTaskGroups[k] = e.Clone()
			}
		}
		o.Soar = m.Soar
		return o
	}
	return nil
}

func InitWeeklyTaskInfo() *WeeklyTaskInfo {
	m := &WeeklyTaskInfo{}
	m.FixNilFields()
	return m
}
func (m *WeeklyTaskInfo) FixNilFields() {
	if m != nil {

		if m.ScoreAwarded == nil {
			m.ScoreAwarded = make(map[uint32]bool)
		}

		if m.AchieveTaskGroups == nil {
			m.AchieveTaskGroups = make(map[uint32]*AchieveTaskGroup)
		}
		for _, itor := range m.AchieveTaskGroups {
			itor.FixNilFields()
		}

	}
}
func (m *Friend) Clone() *Friend {
	if m != nil {
		o := &Friend{}
		o.Id = m.Id
		o.SndLike = m.SndLike
		o.RcvLike = m.RcvLike
		o.Black = m.Black
		o.User = m.User.Clone()
		return o
	}
	return nil
}

func InitFriend() *Friend {
	m := &Friend{}
	m.FixNilFields()
	return m
}
func (m *Friend) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *FriendRequest) Clone() *FriendRequest {
	if m != nil {
		o := &FriendRequest{}
		o.Tm = m.Tm
		o.Id = m.Id
		o.User = m.User.Clone()
		return o
	}
	return nil
}

func InitFriendRequest() *FriendRequest {
	m := &FriendRequest{}
	m.FixNilFields()
	return m
}
func (m *FriendRequest) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *FakeMessage) Clone() *FakeMessage {
	if m != nil {
		o := &FakeMessage{}
		o.Channel = m.Channel
		o.User = m.User.Clone()
		o.Type = m.Type
		o.Value = m.Value
		o.Content = m.Content
		o.Tm = m.Tm
		return o
	}
	return nil
}

func InitFakeMessage() *FakeMessage {
	m := &FakeMessage{}
	m.FixNilFields()
	return m
}
func (m *FakeMessage) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *LeagueCombatChat) Clone() *LeagueCombatChat {
	if m != nil {
		o := &LeagueCombatChat{}
		o.Id = m.Id
		o.Name = m.Name
		o.LeagueName = m.LeagueName
		o.Rank = m.Rank
		o.Score = m.Score
		o.MapId = m.MapId
		o.ShipBoostCnt = m.ShipBoostCnt
		o.AnnounceId = m.AnnounceId
		o.RoomId = m.RoomId
		return o
	}
	return nil
}

func InitLeagueCombatChat() *LeagueCombatChat {
	m := &LeagueCombatChat{}
	m.FixNilFields()
	return m
}
func (m *LeagueCombatChat) FixNilFields() {
	if m != nil {

	}
}
func (m *ChatArgs) Clone() *ChatArgs {
	if m != nil {
		o := &ChatArgs{}
		if len(m.Args) > 0 {
			o.Args = make([]string, len(m.Args))
			copy(o.Args, m.Args)
		}
		return o
	}
	return nil
}

func InitChatArgs() *ChatArgs {
	m := &ChatArgs{}
	m.FixNilFields()
	return m
}
func (m *ChatArgs) FixNilFields() {
	if m != nil {

	}
}
func (m *ChatMessage) Clone() *ChatMessage {
	if m != nil {
		o := &ChatMessage{}
		o.User = m.User.Clone()
		o.Type = m.Type
		if len(m.Data) > 0 {
			o.Data = make([]byte, len(m.Data))
			copy(o.Data, m.Data)
		}
		o.Content = m.Content
		o.Tm = m.Tm
		o.Id = m.Id
		o.Value = m.Value
		o.Custom = m.Custom
		return o
	}
	return nil
}

func InitChatMessage() *ChatMessage {
	m := &ChatMessage{}
	m.FixNilFields()
	return m
}
func (m *ChatMessage) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *ChatInfo) Clone() *ChatInfo {
	if m != nil {
		o := &ChatInfo{}
		o.Uid = m.Uid
		o.Online = m.Online
		return o
	}
	return nil
}

func InitChatInfo() *ChatInfo {
	m := &ChatInfo{}
	m.FixNilFields()
	return m
}
func (m *ChatInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *BanInfo) Clone() *BanInfo {
	if m != nil {
		o := &BanInfo{}
		o.Id = m.Id
		o.Start = m.Start
		o.End = m.End
		return o
	}
	return nil
}

func InitBanInfo() *BanInfo {
	m := &BanInfo{}
	m.FixNilFields()
	return m
}
func (m *BanInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *BanUsers) Clone() *BanUsers {
	if m != nil {
		o := &BanUsers{}
		if len(m.Users) > 0 {
			o.Users = make([]*BanInfo, len(m.Users))
			for k, e := range m.Users {
				o.Users[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBanUsers() *BanUsers {
	m := &BanUsers{}
	m.FixNilFields()
	return m
}
func (m *BanUsers) FixNilFields() {
	if m != nil {

		for _, itor := range m.Users {
			itor.FixNilFields()
		}

	}
}
func (m *Message) Clone() *Message {
	if m != nil {
		o := &Message{}
		o.Id = m.Id
		o.Sender = m.Sender
		o.Content = m.Content
		o.Timestamp = m.Timestamp
		o.Type = m.Type
		if len(m.Data) > 0 {
			o.Data = make([]byte, len(m.Data))
			copy(o.Data, m.Data)
		}
		o.Value = m.Value
		return o
	}
	return nil
}

func InitMessage() *Message {
	m := &Message{}
	m.FixNilFields()
	return m
}
func (m *Message) FixNilFields() {
	if m != nil {

	}
}
func (m *ChannelMessage) Clone() *ChannelMessage {
	if m != nil {
		o := &ChannelMessage{}
		o.Channel = m.Channel
		if len(m.Msgs) > 0 {
			o.Msgs = make([]*ChatMessage, len(m.Msgs))
			for k, e := range m.Msgs {
				o.Msgs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitChannelMessage() *ChannelMessage {
	m := &ChannelMessage{}
	m.FixNilFields()
	return m
}
func (m *ChannelMessage) FixNilFields() {
	if m != nil {

		for _, itor := range m.Msgs {
			itor.FixNilFields()
		}

	}
}
func (m *MessageBoardMsg) Clone() *MessageBoardMsg {
	if m != nil {
		o := &MessageBoardMsg{}
		o.Id = m.Id
		o.Time = m.Time
		o.Content = m.Content
		o.Favor = m.Favor
		o.Stamp = m.Stamp
		o.Head = m.Head.Clone()
		return o
	}
	return nil
}

func InitMessageBoardMsg() *MessageBoardMsg {
	m := &MessageBoardMsg{}
	m.FixNilFields()
	return m
}
func (m *MessageBoardMsg) FixNilFields() {
	if m != nil {

		if m.Head == nil {
			m.Head = &UserSnapshot{}
		}
		m.Head.FixNilFields()

	}
}
func (m *CallAwards) Clone() *CallAwards {
	if m != nil {
		o := &CallAwards{}
		if len(m.Data) > 0 {
			o.Data = make([]*CallAward, len(m.Data))
			for k, e := range m.Data {
				o.Data[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitCallAwards() *CallAwards {
	m := &CallAwards{}
	m.FixNilFields()
	return m
}
func (m *CallAwards) FixNilFields() {
	if m != nil {

		for _, itor := range m.Data {
			itor.FixNilFields()
		}

	}
}
func (m *CallAward) Clone() *CallAward {
	if m != nil {
		o := &CallAward{}
		o.Awarded = m.Awarded
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitCallAward() *CallAward {
	m := &CallAward{}
	m.FixNilFields()
	return m
}
func (m *CallAward) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *Call) Clone() *Call {
	if m != nil {
		o := &Call{}
		if len(m.ProgressAwardId) > 0 {
			o.ProgressAwardId = make([]uint32, len(m.ProgressAwardId))
			copy(o.ProgressAwardId, m.ProgressAwardId)
		}
		if len(m.Progress) > 0 {
			o.Progress = make([]uint32, len(m.Progress))
			copy(o.Progress, m.Progress)
		}
		if len(m.RandNum) > 0 {
			o.RandNum = make([]uint32, len(m.RandNum))
			copy(o.RandNum, m.RandNum)
		}
		o.FreeStartTime = m.FreeStartTime
		o.FreeNum = m.FreeNum
		o.RaceChoice = m.RaceChoice
		o.Target = m.Target.Clone()
		if len(m.Wishs) > 0 {
			o.Wishs = make([]*WishCall, len(m.Wishs))
			for k, e := range m.Wishs {
				o.Wishs[k] = e.Clone()
			}
		}
		if len(m.GuaranteeProgress) > 0 {
			o.GuaranteeProgress = make([]uint32, len(m.GuaranteeProgress))
			copy(o.GuaranteeProgress, m.GuaranteeProgress)
		}
		o.FateScore = m.FateScore
		if len(m.Awards) > 0 {
			o.Awards = make(map[uint32]*CallAwards, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.Limit) > 0 {
			o.Limit = make(map[uint32]*LimitCall, len(m.Limit))
			for k, e := range m.Limit {
				o.Limit[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitCall() *Call {
	m := &Call{}
	m.FixNilFields()
	return m
}
func (m *Call) FixNilFields() {
	if m != nil {

		if m.Target == nil {
			m.Target = &TargetCall{}
		}
		m.Target.FixNilFields()

		for _, itor := range m.Wishs {
			itor.FixNilFields()
		}

		if m.Awards == nil {
			m.Awards = make(map[uint32]*CallAwards)
		}
		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		if m.Limit == nil {
			m.Limit = make(map[uint32]*LimitCall)
		}
		for _, itor := range m.Limit {
			itor.FixNilFields()
		}

	}
}
func (m *LimitCall) Clone() *LimitCall {
	if m != nil {
		o := &LimitCall{}
		o.Id = m.Id
		o.Num = m.Num
		if len(m.KnightCounts) > 0 {
			o.KnightCounts = make(map[uint32]uint32, len(m.KnightCounts))
			for k, e := range m.KnightCounts {
				o.KnightCounts[k] = e
			}
		}
		o.UsedCallCnt = m.UsedCallCnt
		o.AllRandTimes = m.AllRandTimes
		o.LastCheck = m.LastCheck
		o.LastRefreshTime = m.LastRefreshTime
		return o
	}
	return nil
}

func InitLimitCall() *LimitCall {
	m := &LimitCall{}
	m.FixNilFields()
	return m
}
func (m *LimitCall) FixNilFields() {
	if m != nil {

		if m.KnightCounts == nil {
			m.KnightCounts = make(map[uint32]uint32)
		}

	}
}
func (m *WishCall) Clone() *WishCall {
	if m != nil {
		o := &WishCall{}
		o.RefreshTime = m.RefreshTime
		o.OrangeNum = m.OrangeNum
		if len(m.Ids) > 0 {
			o.Ids = make([]uint32, len(m.Ids))
			copy(o.Ids, m.Ids)
		}
		if len(m.FinishPetCnt) > 0 {
			o.FinishPetCnt = make(map[uint32]uint32, len(m.FinishPetCnt))
			for k, e := range m.FinishPetCnt {
				o.FinishPetCnt[k] = e
			}
		}
		return o
	}
	return nil
}

func InitWishCall() *WishCall {
	m := &WishCall{}
	m.FixNilFields()
	return m
}
func (m *WishCall) FixNilFields() {
	if m != nil {

		if m.FinishPetCnt == nil {
			m.FinishPetCnt = make(map[uint32]uint32)
		}

	}
}
func (m *TargetCall) Clone() *TargetCall {
	if m != nil {
		o := &TargetCall{}
		o.Id = m.Id
		o.Num = m.Num
		o.DrawNum = m.DrawNum
		if len(m.Specials) > 0 {
			o.Specials = make([]uint32, len(m.Specials))
			copy(o.Specials, m.Specials)
		}
		return o
	}
	return nil
}

func InitTargetCall() *TargetCall {
	m := &TargetCall{}
	m.FixNilFields()
	return m
}
func (m *TargetCall) FixNilFields() {
	if m != nil {

	}
}
func (m *CallInfo) Clone() *CallInfo {
	if m != nil {
		o := &CallInfo{}
		o.Call = m.Call.Clone()
		if len(m.LeftCallCnt) > 0 {
			o.LeftCallCnt = make(map[uint32]uint32, len(m.LeftCallCnt))
			for k, e := range m.LeftCallCnt {
				o.LeftCallCnt[k] = e
			}
		}
		o.WeeklyFreeTenUsedNum = m.WeeklyFreeTenUsedNum
		return o
	}
	return nil
}

func InitCallInfo() *CallInfo {
	m := &CallInfo{}
	m.FixNilFields()
	return m
}
func (m *CallInfo) FixNilFields() {
	if m != nil {

		if m.Call == nil {
			m.Call = &Call{}
		}
		m.Call.FixNilFields()

		if m.LeftCallCnt == nil {
			m.LeftCallCnt = make(map[uint32]uint32)
		}

	}
}
func (m *PetStatus) Clone() *PetStatus {
	if m != nil {
		o := &PetStatus{}
		o.Id = m.Id
		o.Resolve = m.Resolve
		return o
	}
	return nil
}

func InitPetStatus() *PetStatus {
	m := &PetStatus{}
	m.FixNilFields()
	return m
}
func (m *PetStatus) FixNilFields() {
	if m != nil {

	}
}
func (m *RechargeProduct) Clone() *RechargeProduct {
	if m != nil {
		o := &RechargeProduct{}
		o.Id = m.Id
		o.Cnt = m.Cnt
		o.FirstUsed = m.FirstUsed
		return o
	}
	return nil
}

func InitRechargeProduct() *RechargeProduct {
	m := &RechargeProduct{}
	m.FixNilFields()
	return m
}
func (m *RechargeProduct) FixNilFields() {
	if m != nil {

	}
}
func (m *OrderCustomData) Clone() *OrderCustomData {
	if m != nil {
		o := &OrderCustomData{}
		o.Type = m.Type
		o.Id = m.Id
		if len(m.Value) > 0 {
			o.Value = make([]int64, len(m.Value))
			copy(o.Value, m.Value)
		}
		o.StrData = m.StrData
		o.Amount = m.Amount
		o.Currency = m.Currency
		return o
	}
	return nil
}

func InitOrderCustomData() *OrderCustomData {
	m := &OrderCustomData{}
	m.FixNilFields()
	return m
}
func (m *OrderCustomData) FixNilFields() {
	if m != nil {

	}
}
func (m *RechargeData) Clone() *RechargeData {
	if m != nil {
		o := &RechargeData{}
		o.Type = m.Type
		o.Id = m.Id
		o.ProductId = m.ProductId
		o.Amount = m.Amount
		o.Custom = m.Custom.Clone()
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.OrderId = m.OrderId
		o.Push = m.Push
		return o
	}
	return nil
}

func InitRechargeData() *RechargeData {
	m := &RechargeData{}
	m.FixNilFields()
	return m
}
func (m *RechargeData) FixNilFields() {
	if m != nil {

		if m.Custom == nil {
			m.Custom = &OrderCustomData{}
		}
		m.Custom.FixNilFields()

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *RandomShopCell) Clone() *RandomShopCell {
	if m != nil {
		o := &RandomShopCell{}
		o.Goods = m.Goods
		o.BuyCount = m.BuyCount
		o.Index = m.Index
		return o
	}
	return nil
}

func InitRandomShopCell() *RandomShopCell {
	m := &RandomShopCell{}
	m.FixNilFields()
	return m
}
func (m *RandomShopCell) FixNilFields() {
	if m != nil {

	}
}
func (m *RandomShop) Clone() *RandomShop {
	if m != nil {
		o := &RandomShop{}
		o.ShopType = m.ShopType
		if len(m.Cells) > 0 {
			o.Cells = make([]*RandomShopCell, len(m.Cells))
			for k, e := range m.Cells {
				o.Cells[k] = e.Clone()
			}
		}
		o.NextResetTm = m.NextResetTm
		o.ManualResetCnt = m.ManualResetCnt
		o.FreeResetCnt = m.FreeResetCnt
		return o
	}
	return nil
}

func InitRandomShop() *RandomShop {
	m := &RandomShop{}
	m.FixNilFields()
	return m
}
func (m *RandomShop) FixNilFields() {
	if m != nil {

		for _, itor := range m.Cells {
			itor.FixNilFields()
		}

	}
}
func (m *RedPointIdList) Clone() *RedPointIdList {
	if m != nil {
		o := &RedPointIdList{}
		if len(m.Ids) > 0 {
			o.Ids = make([]uint32, len(m.Ids))
			copy(o.Ids, m.Ids)
		}
		return o
	}
	return nil
}

func InitRedPointIdList() *RedPointIdList {
	m := &RedPointIdList{}
	m.FixNilFields()
	return m
}
func (m *RedPointIdList) FixNilFields() {
	if m != nil {

	}
}
func (m *RollAnnouncement) Clone() *RollAnnouncement {
	if m != nil {
		o := &RollAnnouncement{}
		o.Id = m.Id
		o.UserId = m.UserId
		o.UserName = m.UserName
		if len(m.ParamVals) > 0 {
			o.ParamVals = make([]uint32, len(m.ParamVals))
			copy(o.ParamVals, m.ParamVals)
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.Timestamp = m.Timestamp
		o.PetName = m.PetName
		return o
	}
	return nil
}

func InitRollAnnouncement() *RollAnnouncement {
	m := &RollAnnouncement{}
	m.FixNilFields()
	return m
}
func (m *RollAnnouncement) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *BattleVideoBrief) Clone() *BattleVideoBrief {
	if m != nil {
		o := &BattleVideoBrief{}
		o.Id = m.Id
		o.User = m.User.Clone()
		o.Ext = m.Ext
		return o
	}
	return nil
}

func InitBattleVideoBrief() *BattleVideoBrief {
	m := &BattleVideoBrief{}
	m.FixNilFields()
	return m
}
func (m *BattleVideoBrief) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *BattleVideoWithTeam) Clone() *BattleVideoWithTeam {
	if m != nil {
		o := &BattleVideoWithTeam{}
		o.Id = m.Id
		o.User = m.User.Clone()
		o.Weight = m.Weight
		return o
	}
	return nil
}

func InitBattleVideoWithTeam() *BattleVideoWithTeam {
	m := &BattleVideoWithTeam{}
	m.FixNilFields()
	return m
}
func (m *BattleVideoWithTeam) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserBattleData{}
		}
		m.User.FixNilFields()

	}
}
func (m *ShareBattleVideo) Clone() *ShareBattleVideo {
	if m != nil {
		o := &ShareBattleVideo{}
		o.Id = m.Id
		if len(m.Params) > 0 {
			o.Params = make([]uint32, len(m.Params))
			copy(o.Params, m.Params)
		}
		return o
	}
	return nil
}

func InitShareBattleVideo() *ShareBattleVideo {
	m := &ShareBattleVideo{}
	m.FixNilFields()
	return m
}
func (m *ShareBattleVideo) FixNilFields() {
	if m != nil {

	}
}
func (m *AliveEventInfo) Clone() *AliveEventInfo {
	if m != nil {
		o := &AliveEventInfo{}
		o.Event = m.Event
		o.Status = m.Status
		o.StartTime = m.StartTime
		o.EndTime = m.EndTime
		return o
	}
	return nil
}

func InitAliveEventInfo() *AliveEventInfo {
	m := &AliveEventInfo{}
	m.FixNilFields()
	return m
}
func (m *AliveEventInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *RollingAnnouncementInfo) Clone() *RollingAnnouncementInfo {
	if m != nil {
		o := &RollingAnnouncementInfo{}
		o.Id = m.Id
		o.ServerId = m.ServerId
		if len(m.OpId) > 0 {
			o.OpId = make([]uint32, len(m.OpId))
			copy(o.OpId, m.OpId)
		}
		if len(m.Channel) > 0 {
			o.Channel = make([]uint32, len(m.Channel))
			copy(o.Channel, m.Channel)
		}
		o.RollType = m.RollType
		o.Type = m.Type
		o.Title = m.Title
		o.Des = m.Des
		o.TimeLimit = m.TimeLimit
		o.OpenTime = m.OpenTime
		o.EndTime = m.EndTime
		o.CountDown = m.CountDown
		o.CyclePeriod = m.CyclePeriod
		return o
	}
	return nil
}

func InitRollingAnnouncementInfo() *RollingAnnouncementInfo {
	m := &RollingAnnouncementInfo{}
	m.FixNilFields()
	return m
}
func (m *RollingAnnouncementInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *PopupNotice) Clone() *PopupNotice {
	if m != nil {
		o := &PopupNotice{}
		o.Id = m.Id
		o.ServerId = m.ServerId
		if len(m.OpId) > 0 {
			o.OpId = make([]uint32, len(m.OpId))
			copy(o.OpId, m.OpId)
		}
		o.Title = m.Title
		o.Content = m.Content
		o.StartTime = m.StartTime
		o.EndTime = m.EndTime
		o.CountDown = m.CountDown
		if len(m.Channel) > 0 {
			o.Channel = make([]uint32, len(m.Channel))
			copy(o.Channel, m.Channel)
		}
		return o
	}
	return nil
}

func InitPopupNotice() *PopupNotice {
	m := &PopupNotice{}
	m.FixNilFields()
	return m
}
func (m *PopupNotice) FixNilFields() {
	if m != nil {

	}
}
func (m *Array) Clone() *Array {
	if m != nil {
		o := &Array{}
		o.FormationId = m.FormationId
		if len(m.Ids) > 0 {
			o.Ids = make([]uint32, len(m.Ids))
			copy(o.Ids, m.Ids)
		}
		return o
	}
	return nil
}

func InitArray() *Array {
	m := &Array{}
	m.FixNilFields()
	return m
}
func (m *Array) FixNilFields() {
	if m != nil {

	}
}
func (m *Questionnaire) Clone() *Questionnaire {
	if m != nil {
		o := &Questionnaire{}
		o.Id = m.Id
		o.StartTm = m.StartTm
		o.EndTm = m.EndTm
		o.StartLvl = m.StartLvl
		o.EndLvl = m.EndLvl
		o.StartVip = m.StartVip
		o.EndVip = m.EndVip
		o.SrvDay = m.SrvDay
		o.Address = m.Address
		if len(m.OpId) > 0 {
			o.OpId = make([]uint32, len(m.OpId))
			copy(o.OpId, m.OpId)
		}
		if len(m.Channel) > 0 {
			o.Channel = make([]uint32, len(m.Channel))
			copy(o.Channel, m.Channel)
		}
		return o
	}
	return nil
}

func InitQuestionnaire() *Questionnaire {
	m := &Questionnaire{}
	m.FixNilFields()
	return m
}
func (m *Questionnaire) FixNilFields() {
	if m != nil {

	}
}
func (m *Guide) Clone() *Guide {
	if m != nil {
		o := &Guide{}
		o.Group = m.Group
		o.Step = m.Step
		o.State = m.State
		o.Progress = m.Progress
		o.StepTime = m.StepTime
		return o
	}
	return nil
}

func InitGuide() *Guide {
	m := &Guide{}
	m.FixNilFields()
	return m
}
func (m *Guide) FixNilFields() {
	if m != nil {

	}
}
func (m *GuideInfo) Clone() *GuideInfo {
	if m != nil {
		o := &GuideInfo{}
		if len(m.Guides) > 0 {
			o.Guides = make(map[uint32]*Guide, len(m.Guides))
			for k, e := range m.Guides {
				o.Guides[k] = e.Clone()
			}
		}
		if len(m.WaitSeries) > 0 {
			o.WaitSeries = make([]uint32, len(m.WaitSeries))
			copy(o.WaitSeries, m.WaitSeries)
		}
		if len(m.TriggerCnts) > 0 {
			o.TriggerCnts = make(map[uint32]uint32, len(m.TriggerCnts))
			for k, e := range m.TriggerCnts {
				o.TriggerCnts[k] = e
			}
		}
		return o
	}
	return nil
}

func InitGuideInfo() *GuideInfo {
	m := &GuideInfo{}
	m.FixNilFields()
	return m
}
func (m *GuideInfo) FixNilFields() {
	if m != nil {

		if m.Guides == nil {
			m.Guides = make(map[uint32]*Guide)
		}
		for _, itor := range m.Guides {
			itor.FixNilFields()
		}

		if m.TriggerCnts == nil {
			m.TriggerCnts = make(map[uint32]uint32)
		}

	}
}
func (m *Pray) Clone() *Pray {
	if m != nil {
		o := &Pray{}
		if len(m.Ids) > 0 {
			o.Ids = make([]uint32, len(m.Ids))
			copy(o.Ids, m.Ids)
		}
		o.ChosenId = m.ChosenId
		o.StartTime = m.StartTime
		return o
	}
	return nil
}

func InitPray() *Pray {
	m := &Pray{}
	m.FixNilFields()
	return m
}
func (m *Pray) FixNilFields() {
	if m != nil {

	}
}
func (m *Fashion) Clone() *Fashion {
	if m != nil {
		o := &Fashion{}
		o.Id = m.Id
		o.Star = m.Star
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		if len(m.Exps) > 0 {
			o.Exps = make([]uint32, len(m.Exps))
			copy(o.Exps, m.Exps)
		}
		o.ShowStar = m.ShowStar
		return o
	}
	return nil
}

func InitFashion() *Fashion {
	m := &Fashion{}
	m.FixNilFields()
	return m
}
func (m *Fashion) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

	}
}
func (m *LeaguePosition) Clone() *LeaguePosition {
	if m != nil {
		o := &LeaguePosition{}
		o.Uid = m.Uid
		o.Time = m.Time
		return o
	}
	return nil
}

func InitLeaguePosition() *LeaguePosition {
	m := &LeaguePosition{}
	m.FixNilFields()
	return m
}
func (m *LeaguePosition) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueMember) Clone() *LeagueMember {
	if m != nil {
		o := &LeagueMember{}
		o.Uid = m.Uid
		o.Snap = m.Snap.Clone()
		o.WeeklyActivePoint = m.WeeklyActivePoint
		o.TotalFund = m.TotalFund
		o.Power = m.Power
		return o
	}
	return nil
}

func InitLeagueMember() *LeagueMember {
	m := &LeagueMember{}
	m.FixNilFields()
	return m
}
func (m *LeagueMember) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *LeagueSnapshot) Clone() *LeagueSnapshot {
	if m != nil {
		o := &LeagueSnapshot{}
		o.Id = m.Id
		o.Name = m.Name
		o.Level = m.Level
		o.Badge = m.Badge
		o.Power = m.Power
		o.EntryPower = m.EntryPower
		o.MemberCnt = m.MemberCnt
		o.Leader = m.Leader
		o.LeaderName = m.LeaderName
		o.Announce = m.Announce
		o.WeeklyActivePoint = m.WeeklyActivePoint
		o.Applied = m.Applied
		o.ShipLevel = m.ShipLevel
		o.Claim = m.Claim
		o.ServerId = m.ServerId
		return o
	}
	return nil
}

func InitLeagueSnapshot() *LeagueSnapshot {
	m := &LeagueSnapshot{}
	m.FixNilFields()
	return m
}
func (m *LeagueSnapshot) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueJournal) Clone() *LeagueJournal {
	if m != nil {
		o := &LeagueJournal{}
		o.JournalId = m.JournalId
		o.MemberName = m.MemberName
		o.Progress = m.Progress
		o.Tm = m.Tm
		o.Year = m.Year
		o.LeagueName = m.LeagueName
		return o
	}
	return nil
}

func InitLeagueJournal() *LeagueJournal {
	m := &LeagueJournal{}
	m.FixNilFields()
	return m
}
func (m *LeagueJournal) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueUserNotice) Clone() *LeagueUserNotice {
	if m != nil {
		o := &LeagueUserNotice{}
		o.League = m.League
		o.LeagueName = m.LeagueName
		o.Kicked = m.Kicked
		o.AppointVice = m.AppointVice
		o.BecomeElite = m.BecomeElite
		o.Transfer = m.Transfer
		o.Dismiss = m.Dismiss
		o.Approve = m.Approve
		o.Impeach = m.Impeach
		o.LevelUp = m.LevelUp
		o.NewLevel = m.NewLevel
		o.DismissVice = m.DismissVice
		o.DismissElite = m.DismissElite
		o.ShipLevelUp = m.ShipLevelUp
		o.ShipOldLevel = m.ShipOldLevel
		return o
	}
	return nil
}

func InitLeagueUserNotice() *LeagueUserNotice {
	m := &LeagueUserNotice{}
	m.FixNilFields()
	return m
}
func (m *LeagueUserNotice) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueActivityState) Clone() *LeagueActivityState {
	if m != nil {
		o := &LeagueActivityState{}
		o.Typ = m.Typ
		o.State = m.State
		o.PrepareStartTime = m.PrepareStartTime
		o.RunningStartTime = m.RunningStartTime
		o.FinishedStartTime = m.FinishedStartTime
		o.FinishedEndTime = m.FinishedEndTime
		o.WaitingStartTime = m.WaitingStartTime
		return o
	}
	return nil
}

func InitLeagueActivityState() *LeagueActivityState {
	m := &LeagueActivityState{}
	m.FixNilFields()
	return m
}
func (m *LeagueActivityState) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueTask) Clone() *LeagueTask {
	if m != nil {
		o := &LeagueTask{}
		o.Id = m.Id
		o.Progress = m.Progress
		o.Finish = m.Finish
		return o
	}
	return nil
}

func InitLeagueTask() *LeagueTask {
	m := &LeagueTask{}
	m.FixNilFields()
	return m
}
func (m *LeagueTask) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueDinnerHelpItem) Clone() *LeagueDinnerHelpItem {
	if m != nil {
		o := &LeagueDinnerHelpItem{}
		o.Uid = m.Uid
		o.Name = m.Name
		o.Item = m.Item
		return o
	}
	return nil
}

func InitLeagueDinnerHelpItem() *LeagueDinnerHelpItem {
	m := &LeagueDinnerHelpItem{}
	m.FixNilFields()
	return m
}
func (m *LeagueDinnerHelpItem) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueFightMonsterBox) Clone() *LeagueFightMonsterBox {
	if m != nil {
		o := &LeagueFightMonsterBox{}
		o.TreasureId = m.TreasureId
		o.UserId = m.UserId
		o.UserName = m.UserName
		return o
	}
	return nil
}

func InitLeagueFightMonsterBox() *LeagueFightMonsterBox {
	m := &LeagueFightMonsterBox{}
	m.FixNilFields()
	return m
}
func (m *LeagueFightMonsterBox) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueFightMonsterBoxContainter) Clone() *LeagueFightMonsterBoxContainter {
	if m != nil {
		o := &LeagueFightMonsterBoxContainter{}
		o.MonsterPos = m.MonsterPos
		o.PassedTime = m.PassedTime
		if len(m.BoxList) > 0 {
			o.BoxList = make([]*LeagueFightMonsterBox, len(m.BoxList))
			for k, e := range m.BoxList {
				o.BoxList[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitLeagueFightMonsterBoxContainter() *LeagueFightMonsterBoxContainter {
	m := &LeagueFightMonsterBoxContainter{}
	m.FixNilFields()
	return m
}
func (m *LeagueFightMonsterBoxContainter) FixNilFields() {
	if m != nil {

		for _, itor := range m.BoxList {
			itor.FixNilFields()
		}

	}
}
func (m *LeagueFightLevelBox) Clone() *LeagueFightLevelBox {
	if m != nil {
		o := &LeagueFightLevelBox{}
		o.Level = m.Level
		o.ExpiredZtime = m.ExpiredZtime
		o.MonsterId = m.MonsterId
		if len(m.BoxContainers) > 0 {
			o.BoxContainers = make([]*LeagueFightMonsterBoxContainter, len(m.BoxContainers))
			for k, e := range m.BoxContainers {
				o.BoxContainers[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitLeagueFightLevelBox() *LeagueFightLevelBox {
	m := &LeagueFightLevelBox{}
	m.FixNilFields()
	return m
}
func (m *LeagueFightLevelBox) FixNilFields() {
	if m != nil {

		for _, itor := range m.BoxContainers {
			itor.FixNilFields()
		}

	}
}
func (m *LeagueFightRankUser) Clone() *LeagueFightRankUser {
	if m != nil {
		o := &LeagueFightRankUser{}
		o.TotalHarm = m.TotalHarm
		o.TotalHarmTime = m.TotalHarmTime
		o.MaxHarm = m.MaxHarm
		o.UserId = m.UserId
		return o
	}
	return nil
}

func InitLeagueFightRankUser() *LeagueFightRankUser {
	m := &LeagueFightRankUser{}
	m.FixNilFields()
	return m
}
func (m *LeagueFightRankUser) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueFightMonsterBoxPos) Clone() *LeagueFightMonsterBoxPos {
	if m != nil {
		o := &LeagueFightMonsterBoxPos{}
		o.MonsterPos = m.MonsterPos
		o.BoxPos = m.BoxPos
		return o
	}
	return nil
}

func InitLeagueFightMonsterBoxPos() *LeagueFightMonsterBoxPos {
	m := &LeagueFightMonsterBoxPos{}
	m.FixNilFields()
	return m
}
func (m *LeagueFightMonsterBoxPos) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueFightLevelPos) Clone() *LeagueFightLevelPos {
	if m != nil {
		o := &LeagueFightLevelPos{}
		o.Level = m.Level
		if len(m.MonsterBoxPoss) > 0 {
			o.MonsterBoxPoss = make([]*LeagueFightMonsterBoxPos, len(m.MonsterBoxPoss))
			for k, e := range m.MonsterBoxPoss {
				o.MonsterBoxPoss[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitLeagueFightLevelPos() *LeagueFightLevelPos {
	m := &LeagueFightLevelPos{}
	m.FixNilFields()
	return m
}
func (m *LeagueFightLevelPos) FixNilFields() {
	if m != nil {

		for _, itor := range m.MonsterBoxPoss {
			itor.FixNilFields()
		}

	}
}
func (m *LeagueFightRank) Clone() *LeagueFightRank {
	if m != nil {
		o := &LeagueFightRank{}
		o.MaxLevel = m.MaxLevel
		o.League = m.League.Clone()
		return o
	}
	return nil
}

func InitLeagueFightRank() *LeagueFightRank {
	m := &LeagueFightRank{}
	m.FixNilFields()
	return m
}
func (m *LeagueFightRank) FixNilFields() {
	if m != nil {

		if m.League == nil {
			m.League = &LeagueSnapshot{}
		}
		m.League.FixNilFields()

	}
}
func (m *SignInMonthly) Clone() *SignInMonthly {
	if m != nil {
		o := &SignInMonthly{}
		o.Id = m.Id
		o.Time = m.Time
		o.Start = m.Start
		o.Current = m.Current
		o.FixNum = m.FixNum
		if len(m.States) > 0 {
			o.States = make(map[uint32]uint32, len(m.States))
			for k, e := range m.States {
				o.States[k] = e
			}
		}
		if len(m.ChestIds) > 0 {
			o.ChestIds = make([]uint32, len(m.ChestIds))
			copy(o.ChestIds, m.ChestIds)
		}
		o.CurrentNum = m.CurrentNum
		o.SummaryNum = m.SummaryNum
		return o
	}
	return nil
}

func InitSignInMonthly() *SignInMonthly {
	m := &SignInMonthly{}
	m.FixNilFields()
	return m
}
func (m *SignInMonthly) FixNilFields() {
	if m != nil {

		if m.States == nil {
			m.States = make(map[uint32]uint32)
		}

	}
}
func (m *SignInConfig) Clone() *SignInConfig {
	if m != nil {
		o := &SignInConfig{}
		o.Timestamp = m.Timestamp
		if len(m.Infos) > 0 {
			o.Infos = make([]*SignInInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitSignInConfig() *SignInConfig {
	m := &SignInConfig{}
	m.FixNilFields()
	return m
}
func (m *SignInConfig) FixNilFields() {
	if m != nil {

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

	}
}
func (m *SignInInfo) Clone() *SignInInfo {
	if m != nil {
		o := &SignInInfo{}
		o.Id = m.Id
		o.Name = m.Name
		o.Icon = m.Icon
		o.Level = m.Level
		o.Picture = m.Picture
		o.Title = m.Title
		o.TimeType = m.TimeType
		o.OpenTime = m.OpenTime
		o.EndTime = m.EndTime
		o.AutoJump = m.AutoJump
		o.AutoJumpLevel = m.AutoJumpLevel
		o.AutoJumpNum = m.AutoJumpNum
		o.Version = m.Version
		if len(m.Rewards) > 0 {
			o.Rewards = make([]*SignInRewardInfo, len(m.Rewards))
			for k, e := range m.Rewards {
				o.Rewards[k] = e.Clone()
			}
		}
		o.ViewTime = m.ViewTime
		o.ServerLimit = m.ServerLimit
		return o
	}
	return nil
}

func InitSignInInfo() *SignInInfo {
	m := &SignInInfo{}
	m.FixNilFields()
	return m
}
func (m *SignInInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Rewards {
			itor.FixNilFields()
		}

	}
}
func (m *SignInRewardInfo) Clone() *SignInRewardInfo {
	if m != nil {
		o := &SignInRewardInfo{}
		o.Id = m.Id
		o.MasterId = m.MasterId
		o.Day = m.Day
		o.RewardType = m.RewardType
		o.RewardValue = m.RewardValue
		o.RewardNum = m.RewardNum
		o.RewardImportant = m.RewardImportant
		return o
	}
	return nil
}

func InitSignInRewardInfo() *SignInRewardInfo {
	m := &SignInRewardInfo{}
	m.FixNilFields()
	return m
}
func (m *SignInRewardInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *SignIn) Clone() *SignIn {
	if m != nil {
		o := &SignIn{}
		o.Id = m.Id
		o.Days = m.Days
		o.Time = m.Time
		if len(m.States) > 0 {
			o.States = make(map[uint32]uint32, len(m.States))
			for k, e := range m.States {
				o.States[k] = e
			}
		}
		return o
	}
	return nil
}

func InitSignIn() *SignIn {
	m := &SignIn{}
	m.FixNilFields()
	return m
}
func (m *SignIn) FixNilFields() {
	if m != nil {

		if m.States == nil {
			m.States = make(map[uint32]uint32)
		}

	}
}
func (m *OperateActivityConfig) Clone() *OperateActivityConfig {
	if m != nil {
		o := &OperateActivityConfig{}
		if len(m.UpdateTime) > 0 {
			o.UpdateTime = make(map[uint32]uint32, len(m.UpdateTime))
			for k, e := range m.UpdateTime {
				o.UpdateTime[k] = e
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*OperateActivityInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		if len(m.Pages) > 0 {
			o.Pages = make([]*OperatePageInfo, len(m.Pages))
			for k, e := range m.Pages {
				o.Pages[k] = e.Clone()
			}
		}
		if len(m.Tasks) > 0 {
			o.Tasks = make([]*OperateTaskInfo, len(m.Tasks))
			for k, e := range m.Tasks {
				o.Tasks[k] = e.Clone()
			}
		}
		if len(m.Shops) > 0 {
			o.Shops = make([]*OperateShopInfo, len(m.Shops))
			for k, e := range m.Shops {
				o.Shops[k] = e.Clone()
			}
		}
		if len(m.Exchanges) > 0 {
			o.Exchanges = make([]*OperateExchangeInfo, len(m.Exchanges))
			for k, e := range m.Exchanges {
				o.Exchanges[k] = e.Clone()
			}
		}
		if len(m.Gifts) > 0 {
			o.Gifts = make([]*OperateGiftInfo, len(m.Gifts))
			for k, e := range m.Gifts {
				o.Gifts[k] = e.Clone()
			}
		}
		if len(m.Passes) > 0 {
			o.Passes = make([]*OperatePassInfo, len(m.Passes))
			for k, e := range m.Passes {
				o.Passes[k] = e.Clone()
			}
		}
		if len(m.Recharges) > 0 {
			o.Recharges = make([]*OperateDailyRechargeInfo, len(m.Recharges))
			for k, e := range m.Recharges {
				o.Recharges[k] = e.Clone()
			}
		}
		if len(m.Groups) > 0 {
			o.Groups = make([]*OperateDailyRechargeFreeAwardInfo, len(m.Groups))
			for k, e := range m.Groups {
				o.Groups[k] = e.Clone()
			}
		}
		if len(m.Funds) > 0 {
			o.Funds = make([]*OperateFundAwardInfo, len(m.Funds))
			for k, e := range m.Funds {
				o.Funds[k] = e.Clone()
			}
		}
		if len(m.SignIn) > 0 {
			o.SignIn = make([]*OperateSignInInfo, len(m.SignIn))
			for k, e := range m.SignIn {
				o.SignIn[k] = e.Clone()
			}
		}
		if len(m.GiftCollection) > 0 {
			o.GiftCollection = make([]*OperateGiftCollectionInfo, len(m.GiftCollection))
			for k, e := range m.GiftCollection {
				o.GiftCollection[k] = e.Clone()
			}
		}
		if len(m.GiftExclusive) > 0 {
			o.GiftExclusive = make([]*OperateGiftExclusiveInfo, len(m.GiftExclusive))
			for k, e := range m.GiftExclusive {
				o.GiftExclusive[k] = e.Clone()
			}
		}
		if len(m.LinkageBossTime) > 0 {
			o.LinkageBossTime = make([]*KnightActivityBossTimeInfo, len(m.LinkageBossTime))
			for k, e := range m.LinkageBossTime {
				o.LinkageBossTime[k] = e.Clone()
			}
		}
		if len(m.GiftGroups) > 0 {
			o.GiftGroups = make([]*OperateGiftGroupInfo, len(m.GiftGroups))
			for k, e := range m.GiftGroups {
				o.GiftGroups[k] = e.Clone()
			}
		}
		if len(m.Entrances) > 0 {
			o.Entrances = make([]*OperateEntranceInfo, len(m.Entrances))
			for k, e := range m.Entrances {
				o.Entrances[k] = e.Clone()
			}
		}
		if len(m.ExchangeLevels) > 0 {
			o.ExchangeLevels = make([]*OperateExchangeLevelInfo, len(m.ExchangeLevels))
			for k, e := range m.ExchangeLevels {
				o.ExchangeLevels[k] = e.Clone()
			}
		}
		if len(m.SkinGoods) > 0 {
			o.SkinGoods = make([]*OperateSkinSpecshopGoodsInfo, len(m.SkinGoods))
			for k, e := range m.SkinGoods {
				o.SkinGoods[k] = e.Clone()
			}
		}
		if len(m.Bosses) > 0 {
			o.Bosses = make([]*OperateBossInfo, len(m.Bosses))
			for k, e := range m.Bosses {
				o.Bosses[k] = e.Clone()
			}
		}
		if len(m.BossMaterials) > 0 {
			o.BossMaterials = make([]*OperateBossMaterialInfo, len(m.BossMaterials))
			for k, e := range m.BossMaterials {
				o.BossMaterials[k] = e.Clone()
			}
		}
		if len(m.BossRankRewards) > 0 {
			o.BossRankRewards = make([]*OperateBossRankRewardInfo, len(m.BossRankRewards))
			for k, e := range m.BossRankRewards {
				o.BossRankRewards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateActivityConfig() *OperateActivityConfig {
	m := &OperateActivityConfig{}
	m.FixNilFields()
	return m
}
func (m *OperateActivityConfig) FixNilFields() {
	if m != nil {

		if m.UpdateTime == nil {
			m.UpdateTime = make(map[uint32]uint32)
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

		for _, itor := range m.Pages {
			itor.FixNilFields()
		}

		for _, itor := range m.Tasks {
			itor.FixNilFields()
		}

		for _, itor := range m.Shops {
			itor.FixNilFields()
		}

		for _, itor := range m.Exchanges {
			itor.FixNilFields()
		}

		for _, itor := range m.Gifts {
			itor.FixNilFields()
		}

		for _, itor := range m.Passes {
			itor.FixNilFields()
		}

		for _, itor := range m.Recharges {
			itor.FixNilFields()
		}

		for _, itor := range m.Groups {
			itor.FixNilFields()
		}

		for _, itor := range m.Funds {
			itor.FixNilFields()
		}

		for _, itor := range m.SignIn {
			itor.FixNilFields()
		}

		for _, itor := range m.GiftCollection {
			itor.FixNilFields()
		}

		for _, itor := range m.GiftExclusive {
			itor.FixNilFields()
		}

		for _, itor := range m.LinkageBossTime {
			itor.FixNilFields()
		}

		for _, itor := range m.GiftGroups {
			itor.FixNilFields()
		}

		for _, itor := range m.Entrances {
			itor.FixNilFields()
		}

		for _, itor := range m.ExchangeLevels {
			itor.FixNilFields()
		}

		for _, itor := range m.SkinGoods {
			itor.FixNilFields()
		}

		for _, itor := range m.Bosses {
			itor.FixNilFields()
		}

		for _, itor := range m.BossMaterials {
			itor.FixNilFields()
		}

		for _, itor := range m.BossRankRewards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateActivityInfo) Clone() *OperateActivityInfo {
	if m != nil {
		o := &OperateActivityInfo{}
		o.Id = m.Id
		o.PageId = m.PageId
		o.Type = m.Type
		o.Value = m.Value
		o.Name = m.Name
		o.Icon = m.Icon
		o.Flag = m.Flag
		o.Description = m.Description
		o.Intro = m.Intro
		o.Picture = m.Picture
		o.Npc = m.Npc
		o.TitleFont = m.TitleFont
		o.Level = m.Level
		o.ServerLimit = m.ServerLimit
		o.TimeType = m.TimeType
		o.ViewTime = m.ViewTime
		o.OpenTime = m.OpenTime
		o.EndTime = m.EndTime
		o.ForceEnd = m.ForceEnd
		o.FunctionPic = m.FunctionPic
		o.FunctionTxt = m.FunctionTxt
		if len(m.FunctionBtns) > 0 {
			o.FunctionBtns = make([]uint32, len(m.FunctionBtns))
			copy(o.FunctionBtns, m.FunctionBtns)
		}
		if len(m.Shows) > 0 {
			o.Shows = make([]*Resource, len(m.Shows))
			for k, e := range m.Shows {
				o.Shows[k] = e.Clone()
			}
		}
		o.VipLevel = m.VipLevel
		o.Value2 = m.Value2
		o.ProductId = m.ProductId
		o.Value3 = m.Value3
		o.Value4 = m.Value4
		o.Value5 = m.Value5
		o.EndTime2 = m.EndTime2
		o.PagePriority = m.PagePriority
		o.EffectName = m.EffectName
		if len(m.AwardShows) > 0 {
			o.AwardShows = make([]*Resource, len(m.AwardShows))
			for k, e := range m.AwardShows {
				o.AwardShows[k] = e.Clone()
			}
		}
		o.NpcName = m.NpcName
		o.Offline = m.Offline
		o.EventType = m.EventType
		o.EventValue = m.EventValue
		o.EventProgress = m.EventProgress
		o.TransferType = m.TransferType
		o.TransferValue = m.TransferValue
		o.DisplayTime = m.DisplayTime
		o.PopupDes = m.PopupDes
		o.PopupTitle = m.PopupTitle
		o.IntroIcon = m.IntroIcon
		o.BoardType = m.BoardType
		o.HelpId = m.HelpId
		return o
	}
	return nil
}

func InitOperateActivityInfo() *OperateActivityInfo {
	m := &OperateActivityInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateActivityInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Shows {
			itor.FixNilFields()
		}

		for _, itor := range m.AwardShows {
			itor.FixNilFields()
		}

	}
}
func (m *OperatePageInfo) Clone() *OperatePageInfo {
	if m != nil {
		o := &OperatePageInfo{}
		o.Id = m.Id
		o.Name = m.Name
		o.Picture = m.Picture
		o.Flag = m.Flag
		o.Priority = m.Priority
		o.Entrance = m.Entrance
		o.EntranceGm = m.EntranceGm
		return o
	}
	return nil
}

func InitOperatePageInfo() *OperatePageInfo {
	m := &OperatePageInfo{}
	m.FixNilFields()
	return m
}
func (m *OperatePageInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateEntranceInfo) Clone() *OperateEntranceInfo {
	if m != nil {
		o := &OperateEntranceInfo{}
		o.Id = m.Id
		o.Name = m.Name
		o.Flag = m.Flag
		o.RedPoint = m.RedPoint
		o.IfOpen = m.IfOpen
		o.Time = m.Time
		o.Icon2 = m.Icon2
		o.IconName2 = m.IconName2
		o.Tag2 = m.Tag2
		o.IsDisplay = m.IsDisplay
		o.Icon = m.Icon
		o.Priority = m.Priority
		o.Weight = m.Weight
		o.WorldDisplay = m.WorldDisplay
		return o
	}
	return nil
}

func InitOperateEntranceInfo() *OperateEntranceInfo {
	m := &OperateEntranceInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateEntranceInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateExchangeLevelInfo) Clone() *OperateExchangeLevelInfo {
	if m != nil {
		o := &OperateExchangeLevelInfo{}
		o.Id = m.Id
		o.GroupId = m.GroupId
		o.ActId = m.ActId
		o.Level = m.Level
		o.LevelDes = m.LevelDes
		o.TargetScore = m.TargetScore
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateExchangeLevelInfo() *OperateExchangeLevelInfo {
	m := &OperateExchangeLevelInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateExchangeLevelInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateTaskInfo) Clone() *OperateTaskInfo {
	if m != nil {
		o := &OperateTaskInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Name = m.Name
		o.Event = m.Event
		o.Value1 = m.Value1
		o.Value2 = m.Value2
		o.Progress = m.Progress
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.ResetType = m.ResetType
		return o
	}
	return nil
}

func InitOperateTaskInfo() *OperateTaskInfo {
	m := &OperateTaskInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateTaskInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateShopInfo) Clone() *OperateShopInfo {
	if m != nil {
		o := &OperateShopInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Flag = m.Flag
		o.Event = m.Event
		o.Value1 = m.Value1
		o.Value2 = m.Value2
		o.Progress = m.Progress
		o.Description = m.Description
		o.ResetType = m.ResetType
		o.Number = m.Number
		o.OriginalPrice = m.OriginalPrice
		o.Rebuy = m.Rebuy
		o.Redpoint = m.Redpoint
		if len(m.Goods) > 0 {
			o.Goods = make([]*Resource, len(m.Goods))
			for k, e := range m.Goods {
				o.Goods[k] = e.Clone()
			}
		}
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateShopInfo() *OperateShopInfo {
	m := &OperateShopInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateShopInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Goods {
			itor.FixNilFields()
		}

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

	}
}
func (m *OperateExchangeInfo) Clone() *OperateExchangeInfo {
	if m != nil {
		o := &OperateExchangeInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Flag = m.Flag
		o.Number = m.Number
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		o.ScoreSize = m.ScoreSize
		return o
	}
	return nil
}

func InitOperateExchangeInfo() *OperateExchangeInfo {
	m := &OperateExchangeInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateExchangeInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

	}
}
func (m *OperateGiftInfo) Clone() *OperateGiftInfo {
	if m != nil {
		o := &OperateGiftInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Icon = m.Icon
		o.Name = m.Name
		o.Count = m.Count
		o.Flag = m.Flag
		o.ResetType = m.ResetType
		o.Number = m.Number
		o.OriginalPrice = m.OriginalPrice
		o.Rebuy = m.Rebuy
		o.Redpoint = m.Redpoint
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.ProductId = m.ProductId
		o.Order = m.Order
		o.IsSelect = m.IsSelect
		o.GiftType = m.GiftType
		o.ResourceBuy = m.ResourceBuy
		o.Cost = m.Cost.Clone()
		return o
	}
	return nil
}

func InitOperateGiftInfo() *OperateGiftInfo {
	m := &OperateGiftInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateGiftInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		if m.Cost == nil {
			m.Cost = &Resource{}
		}
		m.Cost.FixNilFields()

	}
}
func (m *OperateGiftGroupInfo) Clone() *OperateGiftGroupInfo {
	if m != nil {
		o := &OperateGiftGroupInfo{}
		o.Id = m.Id
		o.GiftId = m.GiftId
		o.Award = m.Award.Clone()
		return o
	}
	return nil
}

func InitOperateGiftGroupInfo() *OperateGiftGroupInfo {
	m := &OperateGiftGroupInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateGiftGroupInfo) FixNilFields() {
	if m != nil {

		if m.Award == nil {
			m.Award = &Resource{}
		}
		m.Award.FixNilFields()

	}
}
func (m *OperatePassInfo) Clone() *OperatePassInfo {
	if m != nil {
		o := &OperatePassInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Important = m.Important
		o.Event = m.Event
		o.Progress = m.Progress
		o.Intro = m.Intro
		if len(m.LowAwards) > 0 {
			o.LowAwards = make([]*Resource, len(m.LowAwards))
			for k, e := range m.LowAwards {
				o.LowAwards[k] = e.Clone()
			}
		}
		if len(m.HighAwards) > 0 {
			o.HighAwards = make([]*Resource, len(m.HighAwards))
			for k, e := range m.HighAwards {
				o.HighAwards[k] = e.Clone()
			}
		}
		o.Value1 = m.Value1
		o.Value2 = m.Value2
		return o
	}
	return nil
}

func InitOperatePassInfo() *OperatePassInfo {
	m := &OperatePassInfo{}
	m.FixNilFields()
	return m
}
func (m *OperatePassInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.LowAwards {
			itor.FixNilFields()
		}

		for _, itor := range m.HighAwards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateDailyRechargeInfo) Clone() *OperateDailyRechargeInfo {
	if m != nil {
		o := &OperateDailyRechargeInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Day = m.Day
		o.Type = m.Type
		o.Value = m.Value
		o.Name = m.Name
		o.ProductId = m.ProductId
		o.Label = m.Label
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateDailyRechargeInfo() *OperateDailyRechargeInfo {
	m := &OperateDailyRechargeInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateDailyRechargeInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateDailyRechargeFreeAwardInfo) Clone() *OperateDailyRechargeFreeAwardInfo {
	if m != nil {
		o := &OperateDailyRechargeFreeAwardInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateDailyRechargeFreeAwardInfo() *OperateDailyRechargeFreeAwardInfo {
	m := &OperateDailyRechargeFreeAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateDailyRechargeFreeAwardInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateFundAwardInfo) Clone() *OperateFundAwardInfo {
	if m != nil {
		o := &OperateFundAwardInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Day = m.Day
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.Big = m.Big
		return o
	}
	return nil
}

func InitOperateFundAwardInfo() *OperateFundAwardInfo {
	m := &OperateFundAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateFundAwardInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateSignInInfo) Clone() *OperateSignInInfo {
	if m != nil {
		o := &OperateSignInInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.ShowType = m.ShowType
		o.Value = m.Value
		o.RewardType = m.RewardType
		o.RewardValue = m.RewardValue
		o.RewardNum = m.RewardNum
		o.RewardImportant = m.RewardImportant
		return o
	}
	return nil
}

func InitOperateSignInInfo() *OperateSignInInfo {
	m := &OperateSignInInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateSignInInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateGiftCollectionInfo) Clone() *OperateGiftCollectionInfo {
	if m != nil {
		o := &OperateGiftCollectionInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Name = m.Name
		o.Pic = m.Pic
		o.LimitType = m.LimitType
		o.LimitNum = m.LimitNum
		o.Type = m.Type
		o.ProductId = m.ProductId
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		if len(m.Rewards) > 0 {
			o.Rewards = make([]*Resource, len(m.Rewards))
			for k, e := range m.Rewards {
				o.Rewards[k] = e.Clone()
			}
		}
		if len(m.RewardImportants) > 0 {
			o.RewardImportants = make([]uint32, len(m.RewardImportants))
			copy(o.RewardImportants, m.RewardImportants)
		}
		o.Flag = m.Flag
		o.Redpoint = m.Redpoint
		o.RewardNum = m.RewardNum
		o.ShowType = m.ShowType
		o.Privilege = m.Privilege
		return o
	}
	return nil
}

func InitOperateGiftCollectionInfo() *OperateGiftCollectionInfo {
	m := &OperateGiftCollectionInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateGiftCollectionInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

		for _, itor := range m.Rewards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateGiftExclusiveInfo) Clone() *OperateGiftExclusiveInfo {
	if m != nil {
		o := &OperateGiftExclusiveInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Type = m.Type
		o.ProductId = m.ProductId
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		if len(m.Rewards) > 0 {
			o.Rewards = make([]*Resource, len(m.Rewards))
			for k, e := range m.Rewards {
				o.Rewards[k] = e.Clone()
			}
		}
		if len(m.RewardImportants) > 0 {
			o.RewardImportants = make([]uint32, len(m.RewardImportants))
			copy(o.RewardImportants, m.RewardImportants)
		}
		o.Flag = m.Flag
		o.Knight = m.Knight
		o.RewardNum = m.RewardNum
		return o
	}
	return nil
}

func InitOperateGiftExclusiveInfo() *OperateGiftExclusiveInfo {
	m := &OperateGiftExclusiveInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateGiftExclusiveInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

		for _, itor := range m.Rewards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateActivity) Clone() *OperateActivity {
	if m != nil {
		o := &OperateActivity{}
		o.Id = m.Id
		o.Task = m.Task.Clone()
		o.Shopping = m.Shopping.Clone()
		o.Exchange = m.Exchange.Clone()
		o.Pass = m.Pass.Clone()
		o.Gift = m.Gift.Clone()
		o.Days = m.Days.Clone()
		o.Funds = m.Funds.Clone()
		o.Sign = m.Sign.Clone()
		o.GiftCollection = m.GiftCollection.Clone()
		o.GiftExclusive = m.GiftExclusive.Clone()
		o.LinkageBoss = m.LinkageBoss.Clone()
		o.TaskDraw = m.TaskDraw.Clone()
		o.TaskBox = m.TaskBox.Clone()
		o.Drop = m.Drop.Clone()
		o.Pack = m.Pack.Clone()
		o.PassLevel = m.PassLevel.Clone()
		o.Bless = m.Bless.Clone()
		o.Boss = m.Boss.Clone()
		return o
	}
	return nil
}

func InitOperateActivity() *OperateActivity {
	m := &OperateActivity{}
	m.FixNilFields()
	return m
}
func (m *OperateActivity) FixNilFields() {
	if m != nil {

		if m.Task == nil {
			m.Task = &OperateTask{}
		}
		m.Task.FixNilFields()

		if m.Shopping == nil {
			m.Shopping = &OperateShopping{}
		}
		m.Shopping.FixNilFields()

		if m.Exchange == nil {
			m.Exchange = &OperateExchange{}
		}
		m.Exchange.FixNilFields()

		if m.Pass == nil {
			m.Pass = &OperatePass{}
		}
		m.Pass.FixNilFields()

		if m.Gift == nil {
			m.Gift = &OperateGift{}
		}
		m.Gift.FixNilFields()

		if m.Days == nil {
			m.Days = &OperateDailyRecharge{}
		}
		m.Days.FixNilFields()

		if m.Funds == nil {
			m.Funds = &OperateFundAward{}
		}
		m.Funds.FixNilFields()

		if m.Sign == nil {
			m.Sign = &OperateSignIn{}
		}
		m.Sign.FixNilFields()

		if m.GiftCollection == nil {
			m.GiftCollection = &OperateGiftCollection{}
		}
		m.GiftCollection.FixNilFields()

		if m.GiftExclusive == nil {
			m.GiftExclusive = &OperateGiftExclusive{}
		}
		m.GiftExclusive.FixNilFields()

		if m.LinkageBoss == nil {
			m.LinkageBoss = &KnightActivityBoss{}
		}
		m.LinkageBoss.FixNilFields()

		if m.TaskDraw == nil {
			m.TaskDraw = &OperateActivityTaskDraw{}
		}
		m.TaskDraw.FixNilFields()

		if m.TaskBox == nil {
			m.TaskBox = &OperateActivityTaskBox{}
		}
		m.TaskBox.FixNilFields()

		if m.Drop == nil {
			m.Drop = &OperateDrop{}
		}
		m.Drop.FixNilFields()

		if m.Pack == nil {
			m.Pack = &OperatePack{}
		}
		m.Pack.FixNilFields()

		if m.PassLevel == nil {
			m.PassLevel = &OperatePassLevel{}
		}
		m.PassLevel.FixNilFields()

		if m.Bless == nil {
			m.Bless = &OperateBless{}
		}
		m.Bless.FixNilFields()

		if m.Boss == nil {
			m.Boss = &OperateBoss{}
		}
		m.Boss.FixNilFields()

	}
}
func (m *OperateTask) Clone() *OperateTask {
	if m != nil {
		o := &OperateTask{}
		if len(m.States) > 0 {
			o.States = make(map[uint32]*TaskState, len(m.States))
			for k, e := range m.States {
				o.States[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateTask() *OperateTask {
	m := &OperateTask{}
	m.FixNilFields()
	return m
}
func (m *OperateTask) FixNilFields() {
	if m != nil {

		if m.States == nil {
			m.States = make(map[uint32]*TaskState)
		}
		for _, itor := range m.States {
			itor.FixNilFields()
		}

	}
}
func (m *TaskState) Clone() *TaskState {
	if m != nil {
		o := &TaskState{}
		o.Id = m.Id
		o.Progress = m.Progress
		o.Finished = m.Finished
		o.Awarded = m.Awarded
		o.Time = m.Time
		return o
	}
	return nil
}

func InitTaskState() *TaskState {
	m := &TaskState{}
	m.FixNilFields()
	return m
}
func (m *TaskState) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateShopping) Clone() *OperateShopping {
	if m != nil {
		o := &OperateShopping{}
		o.Time = m.Time
		if len(m.Goods) > 0 {
			o.Goods = make(map[uint32]*GoodsState, len(m.Goods))
			for k, e := range m.Goods {
				o.Goods[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateShopping() *OperateShopping {
	m := &OperateShopping{}
	m.FixNilFields()
	return m
}
func (m *OperateShopping) FixNilFields() {
	if m != nil {

		if m.Goods == nil {
			m.Goods = make(map[uint32]*GoodsState)
		}
		for _, itor := range m.Goods {
			itor.FixNilFields()
		}

	}
}
func (m *OperateExchange) Clone() *OperateExchange {
	if m != nil {
		o := &OperateExchange{}
		if len(m.Counts) > 0 {
			o.Counts = make(map[uint32]uint32, len(m.Counts))
			for k, e := range m.Counts {
				o.Counts[k] = e
			}
		}
		return o
	}
	return nil
}

func InitOperateExchange() *OperateExchange {
	m := &OperateExchange{}
	m.FixNilFields()
	return m
}
func (m *OperateExchange) FixNilFields() {
	if m != nil {

		if m.Counts == nil {
			m.Counts = make(map[uint32]uint32)
		}

	}
}
func (m *OperateGroupData) Clone() *OperateGroupData {
	if m != nil {
		o := &OperateGroupData{}
		o.Level = m.Level
		o.Score = m.Score
		return o
	}
	return nil
}

func InitOperateGroupData() *OperateGroupData {
	m := &OperateGroupData{}
	m.FixNilFields()
	return m
}
func (m *OperateGroupData) FixNilFields() {
	if m != nil {

	}
}
func (m *OperatePass) Clone() *OperatePass {
	if m != nil {
		o := &OperatePass{}
		o.Id = m.Id
		o.HighUnlocked = m.HighUnlocked
		o.Progress = m.Progress
		if len(m.LowAwarded) > 0 {
			o.LowAwarded = make([]uint32, len(m.LowAwarded))
			copy(o.LowAwarded, m.LowAwarded)
		}
		if len(m.HighAwarded) > 0 {
			o.HighAwarded = make([]uint32, len(m.HighAwarded))
			copy(o.HighAwarded, m.HighAwarded)
		}
		return o
	}
	return nil
}

func InitOperatePass() *OperatePass {
	m := &OperatePass{}
	m.FixNilFields()
	return m
}
func (m *OperatePass) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateGift) Clone() *OperateGift {
	if m != nil {
		o := &OperateGift{}
		o.Time = m.Time
		if len(m.Goods) > 0 {
			o.Goods = make(map[uint32]*GoodsState, len(m.Goods))
			for k, e := range m.Goods {
				o.Goods[k] = e.Clone()
			}
		}
		if len(m.GiftSelected) > 0 {
			o.GiftSelected = make(map[uint32]uint32, len(m.GiftSelected))
			for k, e := range m.GiftSelected {
				o.GiftSelected[k] = e
			}
		}
		return o
	}
	return nil
}

func InitOperateGift() *OperateGift {
	m := &OperateGift{}
	m.FixNilFields()
	return m
}
func (m *OperateGift) FixNilFields() {
	if m != nil {

		if m.Goods == nil {
			m.Goods = make(map[uint32]*GoodsState)
		}
		for _, itor := range m.Goods {
			itor.FixNilFields()
		}

		if m.GiftSelected == nil {
			m.GiftSelected = make(map[uint32]uint32)
		}

	}
}
func (m *OperateDailyRecharge) Clone() *OperateDailyRecharge {
	if m != nil {
		o := &OperateDailyRecharge{}
		if len(m.BuyIds) > 0 {
			o.BuyIds = make([]uint32, len(m.BuyIds))
			copy(o.BuyIds, m.BuyIds)
		}
		o.FreeAwardedTime = m.FreeAwardedTime
		o.HighAwarded = m.HighAwarded
		return o
	}
	return nil
}

func InitOperateDailyRecharge() *OperateDailyRecharge {
	m := &OperateDailyRecharge{}
	m.FixNilFields()
	return m
}
func (m *OperateDailyRecharge) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateFundAward) Clone() *OperateFundAward {
	if m != nil {
		o := &OperateFundAward{}
		if len(m.Awarded) > 0 {
			o.Awarded = make([]bool, len(m.Awarded))
			copy(o.Awarded, m.Awarded)
		}
		return o
	}
	return nil
}

func InitOperateFundAward() *OperateFundAward {
	m := &OperateFundAward{}
	m.FixNilFields()
	return m
}
func (m *OperateFundAward) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateSignIn) Clone() *OperateSignIn {
	if m != nil {
		o := &OperateSignIn{}
		if len(m.Sign) > 0 {
			o.Sign = make(map[uint32]uint32, len(m.Sign))
			for k, e := range m.Sign {
				o.Sign[k] = e
			}
		}
		return o
	}
	return nil
}

func InitOperateSignIn() *OperateSignIn {
	m := &OperateSignIn{}
	m.FixNilFields()
	return m
}
func (m *OperateSignIn) FixNilFields() {
	if m != nil {

		if m.Sign == nil {
			m.Sign = make(map[uint32]uint32)
		}

	}
}
func (m *OperateGiftCollection) Clone() *OperateGiftCollection {
	if m != nil {
		o := &OperateGiftCollection{}
		o.Time = m.Time
		if len(m.Goods) > 0 {
			o.Goods = make(map[uint32]*GoodsState, len(m.Goods))
			for k, e := range m.Goods {
				o.Goods[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateGiftCollection() *OperateGiftCollection {
	m := &OperateGiftCollection{}
	m.FixNilFields()
	return m
}
func (m *OperateGiftCollection) FixNilFields() {
	if m != nil {

		if m.Goods == nil {
			m.Goods = make(map[uint32]*GoodsState)
		}
		for _, itor := range m.Goods {
			itor.FixNilFields()
		}

	}
}
func (m *OperateGiftExclusive) Clone() *OperateGiftExclusive {
	if m != nil {
		o := &OperateGiftExclusive{}
		if len(m.Goods) > 0 {
			o.Goods = make(map[uint32]*GoodsState, len(m.Goods))
			for k, e := range m.Goods {
				o.Goods[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateGiftExclusive() *OperateGiftExclusive {
	m := &OperateGiftExclusive{}
	m.FixNilFields()
	return m
}
func (m *OperateGiftExclusive) FixNilFields() {
	if m != nil {

		if m.Goods == nil {
			m.Goods = make(map[uint32]*GoodsState)
		}
		for _, itor := range m.Goods {
			itor.FixNilFields()
		}

	}
}
func (m *OperateActivityExtraData) Clone() *OperateActivityExtraData {
	if m != nil {
		o := &OperateActivityExtraData{}
		o.ActId = m.ActId
		o.LinkageBoss = m.LinkageBoss.Clone()
		o.GroupInfos = m.GroupInfos.Clone()
		return o
	}
	return nil
}

func InitOperateActivityExtraData() *OperateActivityExtraData {
	m := &OperateActivityExtraData{}
	m.FixNilFields()
	return m
}
func (m *OperateActivityExtraData) FixNilFields() {
	if m != nil {

		if m.LinkageBoss == nil {
			m.LinkageBoss = &LinkageBossExtraData{}
		}
		m.LinkageBoss.FixNilFields()

		if m.GroupInfos == nil {
			m.GroupInfos = &OperateGroupData{}
		}
		m.GroupInfos.FixNilFields()

	}
}
func (m *LinkageBossExtraData) Clone() *LinkageBossExtraData {
	if m != nil {
		o := &LinkageBossExtraData{}
		if len(m.Awards) > 0 {
			o.Awards = make(map[uint32]bool, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e
			}
		}
		if len(m.Harms) > 0 {
			o.Harms = make(map[uint32]uint64, len(m.Harms))
			for k, e := range m.Harms {
				o.Harms[k] = e
			}
		}
		return o
	}
	return nil
}

func InitLinkageBossExtraData() *LinkageBossExtraData {
	m := &LinkageBossExtraData{}
	m.FixNilFields()
	return m
}
func (m *LinkageBossExtraData) FixNilFields() {
	if m != nil {

		if m.Awards == nil {
			m.Awards = make(map[uint32]bool)
		}

		if m.Harms == nil {
			m.Harms = make(map[uint32]uint64)
		}

	}
}
func (m *PassAwards) Clone() *PassAwards {
	if m != nil {
		o := &PassAwards{}
		o.Id = m.Id
		o.GotLow = m.GotLow
		o.GotHigh = m.GotHigh
		return o
	}
	return nil
}

func InitPassAwards() *PassAwards {
	m := &PassAwards{}
	m.FixNilFields()
	return m
}
func (m *PassAwards) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateTaskDrawAwardInfo) Clone() *OperateTaskDrawAwardInfo {
	if m != nil {
		o := &OperateTaskDrawAwardInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Level = m.Level
		o.LevelNext = m.LevelNext
		o.LevelName = m.LevelName
		o.Des = m.Des
		o.Award = m.Award.Clone()
		o.Prob = m.Prob
		o.IsPrize = m.IsPrize
		o.PrizePicture = m.PrizePicture
		o.Cost = m.Cost.Clone()
		return o
	}
	return nil
}

func InitOperateTaskDrawAwardInfo() *OperateTaskDrawAwardInfo {
	m := &OperateTaskDrawAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateTaskDrawAwardInfo) FixNilFields() {
	if m != nil {

		if m.Award == nil {
			m.Award = &Resource{}
		}
		m.Award.FixNilFields()

		if m.Cost == nil {
			m.Cost = &Resource{}
		}
		m.Cost.FixNilFields()

	}
}
func (m *OperateTaskDrawActiveInfo) Clone() *OperateTaskDrawActiveInfo {
	if m != nil {
		o := &OperateTaskDrawActiveInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Name = m.Name
		o.Event = m.Event
		o.Value = m.Value
		o.Progress = m.Progress
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.Jump = m.Jump
		return o
	}
	return nil
}

func InitOperateTaskDrawActiveInfo() *OperateTaskDrawActiveInfo {
	m := &OperateTaskDrawActiveInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateTaskDrawActiveInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateActivityTaskDrawInfos) Clone() *OperateActivityTaskDrawInfos {
	if m != nil {
		o := &OperateActivityTaskDrawInfos{}
		if len(m.Version) > 0 {
			o.Version = make(map[uint32]uint32, len(m.Version))
			for k, e := range m.Version {
				o.Version[k] = e
			}
		}
		if len(m.AwardInfos) > 0 {
			o.AwardInfos = make([]*OperateTaskDrawAwardInfo, len(m.AwardInfos))
			for k, e := range m.AwardInfos {
				o.AwardInfos[k] = e.Clone()
			}
		}
		if len(m.ActiveInfos) > 0 {
			o.ActiveInfos = make([]*OperateTaskDrawActiveInfo, len(m.ActiveInfos))
			for k, e := range m.ActiveInfos {
				o.ActiveInfos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateActivityTaskDrawInfos() *OperateActivityTaskDrawInfos {
	m := &OperateActivityTaskDrawInfos{}
	m.FixNilFields()
	return m
}
func (m *OperateActivityTaskDrawInfos) FixNilFields() {
	if m != nil {

		if m.Version == nil {
			m.Version = make(map[uint32]uint32)
		}

		for _, itor := range m.AwardInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.ActiveInfos {
			itor.FixNilFields()
		}

	}
}
func (m *OperateActivityTaskDrawActive) Clone() *OperateActivityTaskDrawActive {
	if m != nil {
		o := &OperateActivityTaskDrawActive{}
		o.RefreshTime = m.RefreshTime
		if len(m.Awarded) > 0 {
			o.Awarded = make([]uint32, len(m.Awarded))
			copy(o.Awarded, m.Awarded)
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateActivityTaskDrawActive() *OperateActivityTaskDrawActive {
	m := &OperateActivityTaskDrawActive{}
	m.FixNilFields()
	return m
}
func (m *OperateActivityTaskDrawActive) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *OperateActivityTaskDraw) Clone() *OperateActivityTaskDraw {
	if m != nil {
		o := &OperateActivityTaskDraw{}
		o.Level = m.Level
		if len(m.Records) > 0 {
			o.Records = make(map[uint32]uint32, len(m.Records))
			for k, e := range m.Records {
				o.Records[k] = e
			}
		}
		o.Active = m.Active.Clone()
		return o
	}
	return nil
}

func InitOperateActivityTaskDraw() *OperateActivityTaskDraw {
	m := &OperateActivityTaskDraw{}
	m.FixNilFields()
	return m
}
func (m *OperateActivityTaskDraw) FixNilFields() {
	if m != nil {

		if m.Records == nil {
			m.Records = make(map[uint32]uint32)
		}

		if m.Active == nil {
			m.Active = &OperateActivityTaskDrawActive{}
		}
		m.Active.FixNilFields()

	}
}
func (m *OperateSkinSpecshopGoodsInfo) Clone() *OperateSkinSpecshopGoodsInfo {
	if m != nil {
		o := &OperateSkinSpecshopGoodsInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Good = m.Good.Clone()
		if len(m.Gifts) > 0 {
			o.Gifts = make([]*Resource, len(m.Gifts))
			for k, e := range m.Gifts {
				o.Gifts[k] = e.Clone()
			}
		}
		o.Recharge = m.Recharge
		o.Original = m.Original
		o.Discount = m.Discount
		o.Order = m.Order
		return o
	}
	return nil
}

func InitOperateSkinSpecshopGoodsInfo() *OperateSkinSpecshopGoodsInfo {
	m := &OperateSkinSpecshopGoodsInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateSkinSpecshopGoodsInfo) FixNilFields() {
	if m != nil {

		if m.Good == nil {
			m.Good = &Resource{}
		}
		m.Good.FixNilFields()

		for _, itor := range m.Gifts {
			itor.FixNilFields()
		}

	}
}
func (m *OperateTaskBoxTeamgiftInfo) Clone() *OperateTaskBoxTeamgiftInfo {
	if m != nil {
		o := &OperateTaskBoxTeamgiftInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Picture = m.Picture
		o.ItemPicture = m.ItemPicture
		o.Award = m.Award.Clone()
		o.Level = m.Level
		o.EventId = m.EventId
		o.Relation = m.Relation
		return o
	}
	return nil
}

func InitOperateTaskBoxTeamgiftInfo() *OperateTaskBoxTeamgiftInfo {
	m := &OperateTaskBoxTeamgiftInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateTaskBoxTeamgiftInfo) FixNilFields() {
	if m != nil {

		if m.Award == nil {
			m.Award = &Resource{}
		}
		m.Award.FixNilFields()

	}
}
func (m *OperateActivityTaskBoxInfos) Clone() *OperateActivityTaskBoxInfos {
	if m != nil {
		o := &OperateActivityTaskBoxInfos{}
		if len(m.Version) > 0 {
			o.Version = make(map[uint32]uint32, len(m.Version))
			for k, e := range m.Version {
				o.Version[k] = e
			}
		}
		if len(m.TeamgiftInfos) > 0 {
			o.TeamgiftInfos = make([]*OperateTaskBoxTeamgiftInfo, len(m.TeamgiftInfos))
			for k, e := range m.TeamgiftInfos {
				o.TeamgiftInfos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateActivityTaskBoxInfos() *OperateActivityTaskBoxInfos {
	m := &OperateActivityTaskBoxInfos{}
	m.FixNilFields()
	return m
}
func (m *OperateActivityTaskBoxInfos) FixNilFields() {
	if m != nil {

		if m.Version == nil {
			m.Version = make(map[uint32]uint32)
		}

		for _, itor := range m.TeamgiftInfos {
			itor.FixNilFields()
		}

	}
}
func (m *OperateActivityTaskBox) Clone() *OperateActivityTaskBox {
	if m != nil {
		o := &OperateActivityTaskBox{}
		o.Received = m.Received
		return o
	}
	return nil
}

func InitOperateActivityTaskBox() *OperateActivityTaskBox {
	m := &OperateActivityTaskBox{}
	m.FixNilFields()
	return m
}
func (m *OperateActivityTaskBox) FixNilFields() {
	if m != nil {

	}
}
func (m *OperatePackInfo) Clone() *OperatePackInfo {
	if m != nil {
		o := &OperatePackInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Name = m.Name
		o.Show = m.Show.Clone()
		o.ExcluAward = m.ExcluAward.Clone()
		o.AwardGroup = m.AwardGroup
		o.IsMain = m.IsMain
		o.KnightDes = m.KnightDes
		o.IsLock = m.IsLock
		return o
	}
	return nil
}

func InitOperatePackInfo() *OperatePackInfo {
	m := &OperatePackInfo{}
	m.FixNilFields()
	return m
}
func (m *OperatePackInfo) FixNilFields() {
	if m != nil {

		if m.Show == nil {
			m.Show = &Resource{}
		}
		m.Show.FixNilFields()

		if m.ExcluAward == nil {
			m.ExcluAward = &Resource{}
		}
		m.ExcluAward.FixNilFields()

	}
}
func (m *OperatePackAwardInfo) Clone() *OperatePackAwardInfo {
	if m != nil {
		o := &OperatePackAwardInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Seq = m.Seq
		o.AwardGroup = m.AwardGroup
		o.EventType = m.EventType
		o.EventValue = m.EventValue
		o.EventProgress = m.EventProgress
		o.Intro = m.Intro
		o.IfExclu1 = m.IfExclu1
		if len(m.FreeAwards) > 0 {
			o.FreeAwards = make([]*Resource, len(m.FreeAwards))
			for k, e := range m.FreeAwards {
				o.FreeAwards[k] = e.Clone()
			}
		}
		o.IfExclu2 = m.IfExclu2
		if len(m.PurchaseAwards) > 0 {
			o.PurchaseAwards = make([]*Resource, len(m.PurchaseAwards))
			for k, e := range m.PurchaseAwards {
				o.PurchaseAwards[k] = e.Clone()
			}
		}
		o.ProductId = m.ProductId
		o.BuyLimit = m.BuyLimit
		o.ResourceBuy = m.ResourceBuy
		o.ResourceBuyCost = m.ResourceBuyCost.Clone()
		o.EventShow = m.EventShow
		return o
	}
	return nil
}

func InitOperatePackAwardInfo() *OperatePackAwardInfo {
	m := &OperatePackAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *OperatePackAwardInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.FreeAwards {
			itor.FixNilFields()
		}

		for _, itor := range m.PurchaseAwards {
			itor.FixNilFields()
		}

		if m.ResourceBuyCost == nil {
			m.ResourceBuyCost = &Resource{}
		}
		m.ResourceBuyCost.FixNilFields()

	}
}
func (m *OperatePackInfos) Clone() *OperatePackInfos {
	if m != nil {
		o := &OperatePackInfos{}
		if len(m.Version) > 0 {
			o.Version = make(map[uint32]uint32, len(m.Version))
			for k, e := range m.Version {
				o.Version[k] = e
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*OperatePackInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		if len(m.AwardInfos) > 0 {
			o.AwardInfos = make([]*OperatePackAwardInfo, len(m.AwardInfos))
			for k, e := range m.AwardInfos {
				o.AwardInfos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperatePackInfos() *OperatePackInfos {
	m := &OperatePackInfos{}
	m.FixNilFields()
	return m
}
func (m *OperatePackInfos) FixNilFields() {
	if m != nil {

		if m.Version == nil {
			m.Version = make(map[uint32]uint32)
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

		for _, itor := range m.AwardInfos {
			itor.FixNilFields()
		}

	}
}
func (m *OperatePack) Clone() *OperatePack {
	if m != nil {
		o := &OperatePack{}
		o.SelectId = m.SelectId
		o.Value = m.Value
		o.Progress = m.Progress
		if len(m.FreeAwarded) > 0 {
			o.FreeAwarded = make([]uint32, len(m.FreeAwarded))
			copy(o.FreeAwarded, m.FreeAwarded)
		}
		if len(m.PurchaseAwarded) > 0 {
			o.PurchaseAwarded = make([]*SmallKV, len(m.PurchaseAwarded))
			for k, e := range m.PurchaseAwarded {
				o.PurchaseAwarded[k] = e.Clone()
			}
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.SelectValues) > 0 {
			o.SelectValues = make([]uint32, len(m.SelectValues))
			copy(o.SelectValues, m.SelectValues)
		}
		return o
	}
	return nil
}

func InitOperatePack() *OperatePack {
	m := &OperatePack{}
	m.FixNilFields()
	return m
}
func (m *OperatePack) FixNilFields() {
	if m != nil {

		for _, itor := range m.PurchaseAwarded {
			itor.FixNilFields()
		}

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *OperatePassLevel) Clone() *OperatePassLevel {
	if m != nil {
		o := &OperatePassLevel{}
		o.HighUnlocked = m.HighUnlocked
		o.Level = m.Level
		o.Exp = m.Exp
		if len(m.LowAwarded) > 0 {
			o.LowAwarded = make([]uint32, len(m.LowAwarded))
			copy(o.LowAwarded, m.LowAwarded)
		}
		if len(m.HighAwarded) > 0 {
			o.HighAwarded = make([]uint32, len(m.HighAwarded))
			copy(o.HighAwarded, m.HighAwarded)
		}
		return o
	}
	return nil
}

func InitOperatePassLevel() *OperatePassLevel {
	m := &OperatePassLevel{}
	m.FixNilFields()
	return m
}
func (m *OperatePassLevel) FixNilFields() {
	if m != nil {

	}
}
func (m *OperatePackSync) Clone() *OperatePackSync {
	if m != nil {
		o := &OperatePackSync{}
		o.ActId = m.ActId
		o.Data = m.Data.Clone()
		return o
	}
	return nil
}

func InitOperatePackSync() *OperatePackSync {
	m := &OperatePackSync{}
	m.FixNilFields()
	return m
}
func (m *OperatePackSync) FixNilFields() {
	if m != nil {

		if m.Data == nil {
			m.Data = &OperatePack{}
		}
		m.Data.FixNilFields()

	}
}
func (m *OperateBlessInfo) Clone() *OperateBlessInfo {
	if m != nil {
		o := &OperateBlessInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Name = m.Name
		o.Des = m.Des
		o.UnlockType = m.UnlockType
		o.Number = m.Number
		o.ProductId = m.ProductId
		o.ResetType = m.ResetType
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.GiftbagGroup = m.GiftbagGroup
		o.GiftbagSeq = m.GiftbagSeq
		o.EventType = m.EventType
		o.EventValue = m.EventValue
		o.EventProgress = m.EventProgress
		o.RequirePrice = m.RequirePrice
		return o
	}
	return nil
}

func InitOperateBlessInfo() *OperateBlessInfo {
	m := &OperateBlessInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateBlessInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateBlessInfos) Clone() *OperateBlessInfos {
	if m != nil {
		o := &OperateBlessInfos{}
		if len(m.Version) > 0 {
			o.Version = make(map[uint32]uint32, len(m.Version))
			for k, e := range m.Version {
				o.Version[k] = e
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*OperateBlessInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateBlessInfos() *OperateBlessInfos {
	m := &OperateBlessInfos{}
	m.FixNilFields()
	return m
}
func (m *OperateBlessInfos) FixNilFields() {
	if m != nil {

		if m.Version == nil {
			m.Version = make(map[uint32]uint32)
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

	}
}
func (m *OperateBless) Clone() *OperateBless {
	if m != nil {
		o := &OperateBless{}
		o.Time = m.Time
		if len(m.Goods) > 0 {
			o.Goods = make(map[uint32]*GoodsState, len(m.Goods))
			for k, e := range m.Goods {
				o.Goods[k] = e.Clone()
			}
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateBless() *OperateBless {
	m := &OperateBless{}
	m.FixNilFields()
	return m
}
func (m *OperateBless) FixNilFields() {
	if m != nil {

		if m.Goods == nil {
			m.Goods = make(map[uint32]*GoodsState)
		}
		for _, itor := range m.Goods {
			itor.FixNilFields()
		}

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *OperatePassLevelInfo) Clone() *OperatePassLevelInfo {
	if m != nil {
		o := &OperatePassLevelInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Level = m.Level
		o.Important = m.Important
		if len(m.LevelCosts) > 0 {
			o.LevelCosts = make([]*Resource, len(m.LevelCosts))
			for k, e := range m.LevelCosts {
				o.LevelCosts[k] = e.Clone()
			}
		}
		if len(m.LowAwards) > 0 {
			o.LowAwards = make([]*Resource, len(m.LowAwards))
			for k, e := range m.LowAwards {
				o.LowAwards[k] = e.Clone()
			}
		}
		if len(m.HighAwards) > 0 {
			o.HighAwards = make([]*Resource, len(m.HighAwards))
			for k, e := range m.HighAwards {
				o.HighAwards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperatePassLevelInfo() *OperatePassLevelInfo {
	m := &OperatePassLevelInfo{}
	m.FixNilFields()
	return m
}
func (m *OperatePassLevelInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.LevelCosts {
			itor.FixNilFields()
		}

		for _, itor := range m.LowAwards {
			itor.FixNilFields()
		}

		for _, itor := range m.HighAwards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateBossInfo) Clone() *OperateBossInfo {
	if m != nil {
		o := &OperateBossInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.MaterialGroupKnight = m.MaterialGroupKnight
		o.MaterialGroupThrone = m.MaterialGroupThrone
		o.MaterialGroupHorcrux = m.MaterialGroupHorcrux
		o.MaterialGroupFashion = m.MaterialGroupFashion
		o.MonsterTeamId = m.MonsterTeamId
		o.RankRewardGroup = m.RankRewardGroup
		o.RewardResetType = m.RewardResetType
		if len(m.BattleRewards) > 0 {
			o.BattleRewards = make([]*Resource, len(m.BattleRewards))
			for k, e := range m.BattleRewards {
				o.BattleRewards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateBossInfo() *OperateBossInfo {
	m := &OperateBossInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateBossInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.BattleRewards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateBossMaterialInfo) Clone() *OperateBossMaterialInfo {
	if m != nil {
		o := &OperateBossMaterialInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.MaterialGroup = m.MaterialGroup
		o.MaterialType = m.MaterialType
		o.MaterialValue = m.MaterialValue
		o.MaterialStar = m.MaterialStar
		return o
	}
	return nil
}

func InitOperateBossMaterialInfo() *OperateBossMaterialInfo {
	m := &OperateBossMaterialInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateBossMaterialInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateBossRankRewardInfo) Clone() *OperateBossRankRewardInfo {
	if m != nil {
		o := &OperateBossRankRewardInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.RankRewardGroup = m.RankRewardGroup
		o.RankHigh = m.RankHigh
		o.RankLow = m.RankLow
		o.MailId = m.MailId
		if len(m.Rewards) > 0 {
			o.Rewards = make([]*Resource, len(m.Rewards))
			for k, e := range m.Rewards {
				o.Rewards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateBossRankRewardInfo() *OperateBossRankRewardInfo {
	m := &OperateBossRankRewardInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateBossRankRewardInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Rewards {
			itor.FixNilFields()
		}

	}
}
func (m *CallActivityInfo) Clone() *CallActivityInfo {
	if m != nil {
		o := &CallActivityInfo{}
		o.Id = m.Id
		o.Level = m.Level
		o.ServerLimit = m.ServerLimit
		o.TimeType = m.TimeType
		o.OpenTime = m.OpenTime
		o.EndTime = m.EndTime
		o.PageId = m.PageId
		o.ExtraDes = m.ExtraDes
		if len(m.Shows) > 0 {
			o.Shows = make([]*Resource, len(m.Shows))
			for k, e := range m.Shows {
				o.Shows[k] = e.Clone()
			}
		}
		o.Title = m.Title
		o.HelpTxt = m.HelpTxt
		o.EntranceId = m.EntranceId
		o.PackageId = m.PackageId
		return o
	}
	return nil
}

func InitCallActivityInfo() *CallActivityInfo {
	m := &CallActivityInfo{}
	m.FixNilFields()
	return m
}
func (m *CallActivityInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Shows {
			itor.FixNilFields()
		}

	}
}
func (m *CallActivityCallInfo) Clone() *CallActivityCallInfo {
	if m != nil {
		o := &CallActivityCallInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.ChooseType = m.ChooseType
		o.ThemeType = m.ThemeType
		o.ThemeValue = m.ThemeValue
		o.ThemeProb = m.ThemeProb
		o.Des = m.Des
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitCallActivityCallInfo() *CallActivityCallInfo {
	m := &CallActivityCallInfo{}
	m.FixNilFields()
	return m
}
func (m *CallActivityCallInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *CallActivityChooseInfo) Clone() *CallActivityChooseInfo {
	if m != nil {
		o := &CallActivityChooseInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Award = m.Award.Clone()
		o.IsMain = m.IsMain
		o.MainPic = m.MainPic
		o.Des = m.Des
		return o
	}
	return nil
}

func InitCallActivityChooseInfo() *CallActivityChooseInfo {
	m := &CallActivityChooseInfo{}
	m.FixNilFields()
	return m
}
func (m *CallActivityChooseInfo) FixNilFields() {
	if m != nil {

		if m.Award == nil {
			m.Award = &Resource{}
		}
		m.Award.FixNilFields()

	}
}
func (m *CallActivityContentInfo) Clone() *CallActivityContentInfo {
	if m != nil {
		o := &CallActivityContentInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.PoolType = m.PoolType
		o.IsChoose = m.IsChoose
		o.Award = m.Award.Clone()
		o.Prob = m.Prob
		o.ProbShow = m.ProbShow
		return o
	}
	return nil
}

func InitCallActivityContentInfo() *CallActivityContentInfo {
	m := &CallActivityContentInfo{}
	m.FixNilFields()
	return m
}
func (m *CallActivityContentInfo) FixNilFields() {
	if m != nil {

		if m.Award == nil {
			m.Award = &Resource{}
		}
		m.Award.FixNilFields()

	}
}
func (m *CallActivityProbInfo) Clone() *CallActivityProbInfo {
	if m != nil {
		o := &CallActivityProbInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Number = m.Number
		o.Prob = m.Prob
		return o
	}
	return nil
}

func InitCallActivityProbInfo() *CallActivityProbInfo {
	m := &CallActivityProbInfo{}
	m.FixNilFields()
	return m
}
func (m *CallActivityProbInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *CallActivityEntranceInfo) Clone() *CallActivityEntranceInfo {
	if m != nil {
		o := &CallActivityEntranceInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.SubActId = m.SubActId
		o.SubActName = m.SubActName
		o.SubActIcon = m.SubActIcon
		return o
	}
	return nil
}

func InitCallActivityEntranceInfo() *CallActivityEntranceInfo {
	m := &CallActivityEntranceInfo{}
	m.FixNilFields()
	return m
}
func (m *CallActivityEntranceInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *CallActivityInfos) Clone() *CallActivityInfos {
	if m != nil {
		o := &CallActivityInfos{}
		if len(m.Version) > 0 {
			o.Version = make(map[uint32]uint32, len(m.Version))
			for k, e := range m.Version {
				o.Version[k] = e
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*CallActivityInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		if len(m.CallInfos) > 0 {
			o.CallInfos = make([]*CallActivityCallInfo, len(m.CallInfos))
			for k, e := range m.CallInfos {
				o.CallInfos[k] = e.Clone()
			}
		}
		if len(m.ChooseInfos) > 0 {
			o.ChooseInfos = make([]*CallActivityChooseInfo, len(m.ChooseInfos))
			for k, e := range m.ChooseInfos {
				o.ChooseInfos[k] = e.Clone()
			}
		}
		if len(m.ContentInfos) > 0 {
			o.ContentInfos = make([]*CallActivityContentInfo, len(m.ContentInfos))
			for k, e := range m.ContentInfos {
				o.ContentInfos[k] = e.Clone()
			}
		}
		if len(m.ProbInfos) > 0 {
			o.ProbInfos = make([]*CallActivityProbInfo, len(m.ProbInfos))
			for k, e := range m.ProbInfos {
				o.ProbInfos[k] = e.Clone()
			}
		}
		if len(m.EntranceInfos) > 0 {
			o.EntranceInfos = make([]*CallActivityEntranceInfo, len(m.EntranceInfos))
			for k, e := range m.EntranceInfos {
				o.EntranceInfos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitCallActivityInfos() *CallActivityInfos {
	m := &CallActivityInfos{}
	m.FixNilFields()
	return m
}
func (m *CallActivityInfos) FixNilFields() {
	if m != nil {

		if m.Version == nil {
			m.Version = make(map[uint32]uint32)
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

		for _, itor := range m.CallInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.ChooseInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.ContentInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.ProbInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.EntranceInfos {
			itor.FixNilFields()
		}

	}
}
func (m *CallActivity) Clone() *CallActivity {
	if m != nil {
		o := &CallActivity{}
		o.Id = m.Id
		o.ChooseId = m.ChooseId
		o.CallNum = m.CallNum
		return o
	}
	return nil
}

func InitCallActivity() *CallActivity {
	m := &CallActivity{}
	m.FixNilFields()
	return m
}
func (m *CallActivity) FixNilFields() {
	if m != nil {

	}
}
func (m *FestivalActivityInfo) Clone() *FestivalActivityInfo {
	if m != nil {
		o := &FestivalActivityInfo{}
		o.Id = m.Id
		o.Level = m.Level
		o.ServerLimit = m.ServerLimit
		o.TimeType = m.TimeType
		o.OpenTime = m.OpenTime
		o.EndTime = m.EndTime
		o.Name = m.Name
		o.Des = m.Des
		o.HallTitle = m.HallTitle
		o.HallPicture = m.HallPicture
		o.MapId = m.MapId
		o.HelpId = m.HelpId
		o.SearchTitle = m.SearchTitle
		o.IfDisplay = m.IfDisplay
		o.IfTask = m.IfTask
		o.OperateId = m.OperateId
		o.EntranceId = m.EntranceId
		o.DelayTime = m.DelayTime
		o.BoardType = m.BoardType
		o.GatherId = m.GatherId
		return o
	}
	return nil
}

func InitFestivalActivityInfo() *FestivalActivityInfo {
	m := &FestivalActivityInfo{}
	m.FixNilFields()
	return m
}
func (m *FestivalActivityInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *FestivalActivityTimeInfo) Clone() *FestivalActivityTimeInfo {
	if m != nil {
		o := &FestivalActivityTimeInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.StageId = m.StageId
		o.Name = m.Name
		o.ViewDay = m.ViewDay
		o.OpenDay = m.OpenDay
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.TitleDess) > 0 {
			o.TitleDess = make([]uint32, len(m.TitleDess))
			copy(o.TitleDess, m.TitleDess)
		}
		return o
	}
	return nil
}

func InitFestivalActivityTimeInfo() *FestivalActivityTimeInfo {
	m := &FestivalActivityTimeInfo{}
	m.FixNilFields()
	return m
}
func (m *FestivalActivityTimeInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *FestivalActivitySearchAwardInfo) Clone() *FestivalActivitySearchAwardInfo {
	if m != nil {
		o := &FestivalActivitySearchAwardInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.StageId = m.StageId
		o.SearchValue = m.SearchValue
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitFestivalActivitySearchAwardInfo() *FestivalActivitySearchAwardInfo {
	m := &FestivalActivitySearchAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *FestivalActivitySearchAwardInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *FestivalActivityEntranceInfo) Clone() *FestivalActivityEntranceInfo {
	if m != nil {
		o := &FestivalActivityEntranceInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.SubActId = m.SubActId
		o.Type = m.Type
		o.Event = m.Event
		o.Icon = m.Icon
		o.ActName = m.ActName
		o.PagePriority = m.PagePriority
		o.JumpId = m.JumpId
		o.JumpParam = m.JumpParam
		o.OpenDay = m.OpenDay
		o.EndDay = m.EndDay
		o.Level = m.Level
		o.RedpointType = m.RedpointType
		return o
	}
	return nil
}

func InitFestivalActivityEntranceInfo() *FestivalActivityEntranceInfo {
	m := &FestivalActivityEntranceInfo{}
	m.FixNilFields()
	return m
}
func (m *FestivalActivityEntranceInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *FestivalActivityHallInfo) Clone() *FestivalActivityHallInfo {
	if m != nil {
		o := &FestivalActivityHallInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.SubActId = m.SubActId
		o.HallSort = m.HallSort
		o.ShowType = m.ShowType
		o.NamePic = m.NamePic
		o.HallDes = m.HallDes
		o.Picture = m.Picture
		o.Des = m.Des
		o.ActivityPicture = m.ActivityPicture
		o.ViewDay = m.ViewDay
		o.OpenDay = m.OpenDay
		o.EndDay = m.EndDay
		o.JumpId = m.JumpId
		o.JumpParam = m.JumpParam
		o.Level = m.Level
		o.RedpointType = m.RedpointType
		return o
	}
	return nil
}

func InitFestivalActivityHallInfo() *FestivalActivityHallInfo {
	m := &FestivalActivityHallInfo{}
	m.FixNilFields()
	return m
}
func (m *FestivalActivityHallInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *FestivalActivityInfos) Clone() *FestivalActivityInfos {
	if m != nil {
		o := &FestivalActivityInfos{}
		if len(m.Version) > 0 {
			o.Version = make(map[uint32]uint32, len(m.Version))
			for k, e := range m.Version {
				o.Version[k] = e
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*FestivalActivityInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		if len(m.TimeInfos) > 0 {
			o.TimeInfos = make([]*FestivalActivityTimeInfo, len(m.TimeInfos))
			for k, e := range m.TimeInfos {
				o.TimeInfos[k] = e.Clone()
			}
		}
		if len(m.SearchAwardInfos) > 0 {
			o.SearchAwardInfos = make([]*FestivalActivitySearchAwardInfo, len(m.SearchAwardInfos))
			for k, e := range m.SearchAwardInfos {
				o.SearchAwardInfos[k] = e.Clone()
			}
		}
		if len(m.EntranceInfos) > 0 {
			o.EntranceInfos = make([]*FestivalActivityEntranceInfo, len(m.EntranceInfos))
			for k, e := range m.EntranceInfos {
				o.EntranceInfos[k] = e.Clone()
			}
		}
		if len(m.HallInfos) > 0 {
			o.HallInfos = make([]*FestivalActivityHallInfo, len(m.HallInfos))
			for k, e := range m.HallInfos {
				o.HallInfos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitFestivalActivityInfos() *FestivalActivityInfos {
	m := &FestivalActivityInfos{}
	m.FixNilFields()
	return m
}
func (m *FestivalActivityInfos) FixNilFields() {
	if m != nil {

		if m.Version == nil {
			m.Version = make(map[uint32]uint32)
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

		for _, itor := range m.TimeInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.SearchAwardInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.EntranceInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.HallInfos {
			itor.FixNilFields()
		}

	}
}
func (m *FestivalActivityStage) Clone() *FestivalActivityStage {
	if m != nil {
		o := &FestivalActivityStage{}
		if len(m.FinishedEvents) > 0 {
			o.FinishedEvents = make(map[uint32]*Uint32S, len(m.FinishedEvents))
			for k, e := range m.FinishedEvents {
				o.FinishedEvents[k] = e.Clone()
			}
		}
		if len(m.ReceivedAwards) > 0 {
			o.ReceivedAwards = make([]uint32, len(m.ReceivedAwards))
			copy(o.ReceivedAwards, m.ReceivedAwards)
		}
		if len(m.Budos) > 0 {
			o.Budos = make([]*WorldBudo, len(m.Budos))
			for k, e := range m.Budos {
				o.Budos[k] = e.Clone()
			}
		}
		o.Progress = m.Progress
		return o
	}
	return nil
}

func InitFestivalActivityStage() *FestivalActivityStage {
	m := &FestivalActivityStage{}
	m.FixNilFields()
	return m
}
func (m *FestivalActivityStage) FixNilFields() {
	if m != nil {

		if m.FinishedEvents == nil {
			m.FinishedEvents = make(map[uint32]*Uint32S)
		}
		for _, itor := range m.FinishedEvents {
			itor.FixNilFields()
		}

		for _, itor := range m.Budos {
			itor.FixNilFields()
		}

	}
}
func (m *FestivalActivity) Clone() *FestivalActivity {
	if m != nil {
		o := &FestivalActivity{}
		o.Id = m.Id
		if len(m.Stages) > 0 {
			o.Stages = make(map[uint32]*FestivalActivityStage, len(m.Stages))
			for k, e := range m.Stages {
				o.Stages[k] = e.Clone()
			}
		}
		o.TotalGather = m.TotalGather
		return o
	}
	return nil
}

func InitFestivalActivity() *FestivalActivity {
	m := &FestivalActivity{}
	m.FixNilFields()
	return m
}
func (m *FestivalActivity) FixNilFields() {
	if m != nil {

		if m.Stages == nil {
			m.Stages = make(map[uint32]*FestivalActivityStage)
		}
		for _, itor := range m.Stages {
			itor.FixNilFields()
		}

	}
}
func (m *FestivalActivityWorldParam) Clone() *FestivalActivityWorldParam {
	if m != nil {
		o := &FestivalActivityWorldParam{}
		o.ActId = m.ActId
		o.StageId = m.StageId
		o.TaskId = m.TaskId
		o.EventId = m.EventId
		return o
	}
	return nil
}

func InitFestivalActivityWorldParam() *FestivalActivityWorldParam {
	m := &FestivalActivityWorldParam{}
	m.FixNilFields()
	return m
}
func (m *FestivalActivityWorldParam) FixNilFields() {
	if m != nil {

	}
}
func (m *GatherScreen) Clone() *GatherScreen {
	if m != nil {
		o := &GatherScreen{}
		o.Id = m.Id
		o.Username = m.Username
		o.Times = m.Times
		o.ItemId = m.ItemId
		o.ItemCount = m.ItemCount
		o.Time = m.Time
		return o
	}
	return nil
}

func InitGatherScreen() *GatherScreen {
	m := &GatherScreen{}
	m.FixNilFields()
	return m
}
func (m *GatherScreen) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateDropInfo) Clone() *OperateDropInfo {
	if m != nil {
		o := &OperateDropInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.DropMappingId = m.DropMappingId
		o.Value = m.Value
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.LimitType = m.LimitType
		o.LimitSize = m.LimitSize
		return o
	}
	return nil
}

func InitOperateDropInfo() *OperateDropInfo {
	m := &OperateDropInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateDropInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateDropState) Clone() *OperateDropState {
	if m != nil {
		o := &OperateDropState{}
		o.DropId = m.DropId
		o.Value = m.Value
		o.DropNum = m.DropNum
		o.ResetTime = m.ResetTime
		return o
	}
	return nil
}

func InitOperateDropState() *OperateDropState {
	m := &OperateDropState{}
	m.FixNilFields()
	return m
}
func (m *OperateDropState) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateDrop) Clone() *OperateDrop {
	if m != nil {
		o := &OperateDrop{}
		if len(m.States) > 0 {
			o.States = make(map[uint32]*OperateDropState, len(m.States))
			for k, e := range m.States {
				o.States[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateDrop() *OperateDrop {
	m := &OperateDrop{}
	m.FixNilFields()
	return m
}
func (m *OperateDrop) FixNilFields() {
	if m != nil {

		if m.States == nil {
			m.States = make(map[uint32]*OperateDropState)
		}
		for _, itor := range m.States {
			itor.FixNilFields()
		}

	}
}
func (m *Rebate) Clone() *Rebate {
	if m != nil {
		o := &Rebate{}
		o.Status = m.Status
		o.RechargeAmount = m.RechargeAmount
		o.RebateServer = m.RebateServer
		o.UserName = m.UserName
		return o
	}
	return nil
}

func InitRebate() *Rebate {
	m := &Rebate{}
	m.FixNilFields()
	return m
}
func (m *Rebate) FixNilFields() {
	if m != nil {

	}
}
func (m *BulletScreen) Clone() *BulletScreen {
	if m != nil {
		o := &BulletScreen{}
		o.Id = m.Id
		o.UserName = m.UserName
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.Timestamp = m.Timestamp
		if len(m.Params) > 0 {
			o.Params = make([]uint64, len(m.Params))
			copy(o.Params, m.Params)
		}
		o.UserNameOther = m.UserNameOther
		o.Uid = m.Uid
		return o
	}
	return nil
}

func InitBulletScreen() *BulletScreen {
	m := &BulletScreen{}
	m.FixNilFields()
	return m
}
func (m *BulletScreen) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *TriggerGift) Clone() *TriggerGift {
	if m != nil {
		o := &TriggerGift{}
		o.Id = m.Id
		o.Progress = m.Progress
		o.TriggerTime = m.TriggerTime
		o.EndTime = m.EndTime
		o.BuyTime = m.BuyTime
		o.Event = m.Event
		o.BuyNum = m.BuyNum
		o.BatchSeq = m.BatchSeq
		return o
	}
	return nil
}

func InitTriggerGift() *TriggerGift {
	m := &TriggerGift{}
	m.FixNilFields()
	return m
}
func (m *TriggerGift) FixNilFields() {
	if m != nil {

	}
}
func (m *CarnivalCondition) Clone() *CarnivalCondition {
	if m != nil {
		o := &CarnivalCondition{}
		o.Event = m.Event
		if len(m.Days) > 0 {
			o.Days = make(map[uint32]*Condition, len(m.Days))
			for k, e := range m.Days {
				o.Days[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitCarnivalCondition() *CarnivalCondition {
	m := &CarnivalCondition{}
	m.FixNilFields()
	return m
}
func (m *CarnivalCondition) FixNilFields() {
	if m != nil {

		if m.Days == nil {
			m.Days = make(map[uint32]*Condition)
		}
		for _, itor := range m.Days {
			itor.FixNilFields()
		}

	}
}
func (m *CarnivalData) Clone() *CarnivalData {
	if m != nil {
		o := &CarnivalData{}
		o.ActId = m.ActId
		o.Score = m.Score
		if len(m.ScoreAwardIds) > 0 {
			o.ScoreAwardIds = make([]uint32, len(m.ScoreAwardIds))
			copy(o.ScoreAwardIds, m.ScoreAwardIds)
		}
		if len(m.TaskAwardDays) > 0 {
			o.TaskAwardDays = make([]uint32, len(m.TaskAwardDays))
			copy(o.TaskAwardDays, m.TaskAwardDays)
		}
		if len(m.TaskAwardIds) > 0 {
			o.TaskAwardIds = make([]uint32, len(m.TaskAwardIds))
			copy(o.TaskAwardIds, m.TaskAwardIds)
		}
		if len(m.GoodsStates) > 0 {
			o.GoodsStates = make(map[uint32]*GoodsState, len(m.GoodsStates))
			for k, e := range m.GoodsStates {
				o.GoodsStates[k] = e.Clone()
			}
		}
		if len(m.Conds) > 0 {
			o.Conds = make(map[uint32]*CarnivalCondition, len(m.Conds))
			for k, e := range m.Conds {
				o.Conds[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitCarnivalData() *CarnivalData {
	m := &CarnivalData{}
	m.FixNilFields()
	return m
}
func (m *CarnivalData) FixNilFields() {
	if m != nil {

		if m.GoodsStates == nil {
			m.GoodsStates = make(map[uint32]*GoodsState)
		}
		for _, itor := range m.GoodsStates {
			itor.FixNilFields()
		}

		if m.Conds == nil {
			m.Conds = make(map[uint32]*CarnivalCondition)
		}
		for _, itor := range m.Conds {
			itor.FixNilFields()
		}

	}
}
func (m *MonthlyCard) Clone() *MonthlyCard {
	if m != nil {
		o := &MonthlyCard{}
		o.CardType = m.CardType
		o.EndDayZero = m.EndDayZero
		o.LastAwardedDayZero = m.LastAwardedDayZero
		return o
	}
	return nil
}

func InitMonthlyCard() *MonthlyCard {
	m := &MonthlyCard{}
	m.FixNilFields()
	return m
}
func (m *MonthlyCard) FixNilFields() {
	if m != nil {

	}
}
func (m *Giftbag) Clone() *Giftbag {
	if m != nil {
		o := &Giftbag{}
		o.ResetType = m.ResetType
		o.Id = m.Id
		if len(m.Goods) > 0 {
			o.Goods = make([]*GiftbagBuyStatus, len(m.Goods))
			for k, e := range m.Goods {
				o.Goods[k] = e.Clone()
			}
		}
		o.GoodsResetTime = m.GoodsResetTime
		o.BuyResetTime = m.BuyResetTime
		o.LastUpdateLevel = m.LastUpdateLevel
		return o
	}
	return nil
}

func InitGiftbag() *Giftbag {
	m := &Giftbag{}
	m.FixNilFields()
	return m
}
func (m *Giftbag) FixNilFields() {
	if m != nil {

		for _, itor := range m.Goods {
			itor.FixNilFields()
		}

	}
}
func (m *GiftbagBuyStatus) Clone() *GiftbagBuyStatus {
	if m != nil {
		o := &GiftbagBuyStatus{}
		o.GoodGroup = m.GoodGroup
		o.Step = m.Step
		o.Count = m.Count
		return o
	}
	return nil
}

func InitGiftbagBuyStatus() *GiftbagBuyStatus {
	m := &GiftbagBuyStatus{}
	m.FixNilFields()
	return m
}
func (m *GiftbagBuyStatus) FixNilFields() {
	if m != nil {

	}
}
func (m *Meridian) Clone() *Meridian {
	if m != nil {
		o := &Meridian{}
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.Level = m.Level
		o.Exp = m.Exp
		o.Star = m.Star
		o.Point = m.Point
		o.TotalExp = m.TotalExp
		if len(m.ProAttrList) > 0 {
			o.ProAttrList = make([]uint32, len(m.ProAttrList))
			copy(o.ProAttrList, m.ProAttrList)
		}
		if len(m.StarCost) > 0 {
			o.StarCost = make([]*MeridianStarCost, len(m.StarCost))
			for k, e := range m.StarCost {
				o.StarCost[k] = e.Clone()
			}
		}
		if len(m.Skills) > 0 {
			o.Skills = make([]*SmallKV, len(m.Skills))
			for k, e := range m.Skills {
				o.Skills[k] = e.Clone()
			}
		}
		o.AwakeFromBaseId = m.AwakeFromBaseId
		if len(m.AwakeCost) > 0 {
			o.AwakeCost = make([]*Resource, len(m.AwakeCost))
			for k, e := range m.AwakeCost {
				o.AwakeCost[k] = e.Clone()
			}
		}
		o.Fate = m.Fate
		o.FateStage = m.FateStage
		if len(m.FateCost) > 0 {
			o.FateCost = make([]*Resource, len(m.FateCost))
			for k, e := range m.FateCost {
				o.FateCost[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitMeridian() *Meridian {
	m := &Meridian{}
	m.FixNilFields()
	return m
}
func (m *Meridian) FixNilFields() {
	if m != nil {

		for _, itor := range m.StarCost {
			itor.FixNilFields()
		}

		for _, itor := range m.Skills {
			itor.FixNilFields()
		}

		for _, itor := range m.AwakeCost {
			itor.FixNilFields()
		}

		for _, itor := range m.FateCost {
			itor.FixNilFields()
		}

	}
}
func (m *MeridianStarCost) Clone() *MeridianStarCost {
	if m != nil {
		o := &MeridianStarCost{}
		o.Id = m.Id
		o.Num = m.Num
		return o
	}
	return nil
}

func InitMeridianStarCost() *MeridianStarCost {
	m := &MeridianStarCost{}
	m.FixNilFields()
	return m
}
func (m *MeridianStarCost) FixNilFields() {
	if m != nil {

	}
}
func (m *MatchFightInfo) Clone() *MatchFightInfo {
	if m != nil {
		o := &MatchFightInfo{}
		o.ResetTime = m.ResetTime
		o.Times = m.Times
		o.WinTimes = m.WinTimes
		o.Credits = m.Credits
		o.Changes = m.Changes
		o.MaxCredits = m.MaxCredits
		o.LocalRank = m.LocalRank
		o.CrossRank = m.CrossRank
		o.BlessId = m.BlessId
		o.BlessUsed = m.BlessUsed
		o.BlessNum = m.BlessNum
		o.ActivePoints = m.ActivePoints
		o.MatchTimes = m.MatchTimes
		return o
	}
	return nil
}

func InitMatchFightInfo() *MatchFightInfo {
	m := &MatchFightInfo{}
	m.FixNilFields()
	return m
}
func (m *MatchFightInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *MatchFightTask) Clone() *MatchFightTask {
	if m != nil {
		o := &MatchFightTask{}
		o.ResetTime = m.ResetTime
		if len(m.Awarded) > 0 {
			o.Awarded = make([]uint32, len(m.Awarded))
			copy(o.Awarded, m.Awarded)
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitMatchFightTask() *MatchFightTask {
	m := &MatchFightTask{}
	m.FixNilFields()
	return m
}
func (m *MatchFightTask) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *BriefVideo) Clone() *BriefVideo {
	if m != nil {
		o := &BriefVideo{}
		o.Id = m.Id
		o.Time = m.Time
		o.Win = m.Win
		o.Attacker = m.Attacker.Clone()
		o.Defender = m.Defender.Clone()
		o.DefenderRobotId = m.DefenderRobotId
		o.ShowValue = m.ShowValue
		return o
	}
	return nil
}

func InitBriefVideo() *BriefVideo {
	m := &BriefVideo{}
	m.FixNilFields()
	return m
}
func (m *BriefVideo) FixNilFields() {
	if m != nil {

		if m.Attacker == nil {
			m.Attacker = &UserSnapshot{}
		}
		m.Attacker.FixNilFields()

		if m.Defender == nil {
			m.Defender = &UserSnapshot{}
		}
		m.Defender.FixNilFields()

	}
}
func (m *HistoryCallDrawTarget) Clone() *HistoryCallDrawTarget {
	if m != nil {
		o := &HistoryCallDrawTarget{}
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHistoryCallDrawTarget() *HistoryCallDrawTarget {
	m := &HistoryCallDrawTarget{}
	m.FixNilFields()
	return m
}
func (m *HistoryCallDrawTarget) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *HistoryCallDraw) Clone() *HistoryCallDraw {
	if m != nil {
		o := &HistoryCallDraw{}
		if len(m.Pets) > 0 {
			o.Pets = make([]*PetStatus, len(m.Pets))
			for k, e := range m.Pets {
				o.Pets[k] = e.Clone()
			}
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHistoryCallDraw() *HistoryCallDraw {
	m := &HistoryCallDraw{}
	m.FixNilFields()
	return m
}
func (m *HistoryCallDraw) FixNilFields() {
	if m != nil {

		for _, itor := range m.Pets {
			itor.FixNilFields()
		}

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *HistoryLuckyDraw) Clone() *HistoryLuckyDraw {
	if m != nil {
		o := &HistoryLuckyDraw{}
		o.Times = m.Times
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.ReturnAwards) > 0 {
			o.ReturnAwards = make([]*Resource, len(m.ReturnAwards))
			for k, e := range m.ReturnAwards {
				o.ReturnAwards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHistoryLuckyDraw() *HistoryLuckyDraw {
	m := &HistoryLuckyDraw{}
	m.FixNilFields()
	return m
}
func (m *HistoryLuckyDraw) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		for _, itor := range m.ReturnAwards {
			itor.FixNilFields()
		}

	}
}
func (m *HistoryKnightActivityCall) Clone() *HistoryKnightActivityCall {
	if m != nil {
		o := &HistoryKnightActivityCall{}
		o.Times = m.Times
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHistoryKnightActivityCall() *HistoryKnightActivityCall {
	m := &HistoryKnightActivityCall{}
	m.FixNilFields()
	return m
}
func (m *HistoryKnightActivityCall) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *HistoryLeagueDinner) Clone() *HistoryLeagueDinner {
	if m != nil {
		o := &HistoryLeagueDinner{}
		o.Times = m.Times
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHistoryLeagueDinner() *HistoryLeagueDinner {
	m := &HistoryLeagueDinner{}
	m.FixNilFields()
	return m
}
func (m *HistoryLeagueDinner) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *HistoryTreasureDraw) Clone() *HistoryTreasureDraw {
	if m != nil {
		o := &HistoryTreasureDraw{}
		o.Times = m.Times
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHistoryTreasureDraw() *HistoryTreasureDraw {
	m := &HistoryTreasureDraw{}
	m.FixNilFields()
	return m
}
func (m *HistoryTreasureDraw) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *HistoryCall) Clone() *HistoryCall {
	if m != nil {
		o := &HistoryCall{}
		o.Times = m.Times
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHistoryCall() *HistoryCall {
	m := &HistoryCall{}
	m.FixNilFields()
	return m
}
func (m *HistoryCall) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *HistoryBase) Clone() *HistoryBase {
	if m != nil {
		o := &HistoryBase{}
		o.Time = m.Time
		o.CallDraw = m.CallDraw.Clone()
		o.LuckyDraw = m.LuckyDraw.Clone()
		o.CallDrawTarget = m.CallDrawTarget.Clone()
		o.KnightActivityCall = m.KnightActivityCall.Clone()
		o.CardDraw = m.CardDraw.Clone()
		o.LeagueDinner = m.LeagueDinner.Clone()
		o.TreasureDraw = m.TreasureDraw.Clone()
		o.CallActivityDraw = m.CallActivityDraw.Clone()
		return o
	}
	return nil
}

func InitHistoryBase() *HistoryBase {
	m := &HistoryBase{}
	m.FixNilFields()
	return m
}
func (m *HistoryBase) FixNilFields() {
	if m != nil {

		if m.CallDraw == nil {
			m.CallDraw = &HistoryCallDraw{}
		}
		m.CallDraw.FixNilFields()

		if m.LuckyDraw == nil {
			m.LuckyDraw = &HistoryLuckyDraw{}
		}
		m.LuckyDraw.FixNilFields()

		if m.CallDrawTarget == nil {
			m.CallDrawTarget = &HistoryCallDrawTarget{}
		}
		m.CallDrawTarget.FixNilFields()

		if m.KnightActivityCall == nil {
			m.KnightActivityCall = &HistoryKnightActivityCall{}
		}
		m.KnightActivityCall.FixNilFields()

		if m.CardDraw == nil {
			m.CardDraw = &HistoryCardDraw{}
		}
		m.CardDraw.FixNilFields()

		if m.LeagueDinner == nil {
			m.LeagueDinner = &HistoryLeagueDinner{}
		}
		m.LeagueDinner.FixNilFields()

		if m.TreasureDraw == nil {
			m.TreasureDraw = &HistoryTreasureDraw{}
		}
		m.TreasureDraw.FixNilFields()

		if m.CallActivityDraw == nil {
			m.CallActivityDraw = &HistoryCall{}
		}
		m.CallActivityDraw.FixNilFields()

	}
}
func (m *DrawInfo) Clone() *DrawInfo {
	if m != nil {
		o := &DrawInfo{}
		o.Id = m.Id
		o.Level = m.Level
		o.TimeType = m.TimeType
		o.OpenTime = m.OpenTime
		o.EndTime = m.EndTime
		o.Icon = m.Icon
		o.Name = m.Name
		o.Description = m.Description
		o.CostType = m.CostType
		o.CostValue = m.CostValue
		o.CostSize = m.CostSize
		o.RewardType = m.RewardType
		o.RewardValue = m.RewardValue
		o.RewardSize = m.RewardSize
		o.ForceEnd = m.ForceEnd
		o.GuaranteedNum = m.GuaranteedNum
		o.DailyDrawLimit = m.DailyDrawLimit
		o.ServerLimit = m.ServerLimit
		o.ScoreSwitch = m.ScoreSwitch
		o.ExchangeSwitch = m.ExchangeSwitch
		o.GiftSwitch = m.GiftSwitch
		o.HelpId = m.HelpId
		return o
	}
	return nil
}

func InitDrawInfo() *DrawInfo {
	m := &DrawInfo{}
	m.FixNilFields()
	return m
}
func (m *DrawInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *DrawTypeInfo) Clone() *DrawTypeInfo {
	if m != nil {
		o := &DrawTypeInfo{}
		o.Id = m.Id
		o.ActivityId = m.ActivityId
		o.Type = m.Type
		o.TimeType = m.TimeType
		o.OpenTime = m.OpenTime
		o.EndTime = m.EndTime
		o.TitleFont = m.TitleFont
		o.Name = m.Name
		o.Icon = m.Icon
		o.Background = m.Background
		o.ShowType1 = m.ShowType1
		o.ShowValue1 = m.ShowValue1
		o.ShowType2 = m.ShowType2
		o.ShowValue2 = m.ShowValue2
		o.Picture = m.Picture
		o.FunctionBtn = m.FunctionBtn
		o.FunctionTxt = m.FunctionTxt
		o.FunctionPic = m.FunctionPic
		o.Desc = m.Desc
		o.PageId = m.PageId
		o.BoardType = m.BoardType
		return o
	}
	return nil
}

func InitDrawTypeInfo() *DrawTypeInfo {
	m := &DrawTypeInfo{}
	m.FixNilFields()
	return m
}
func (m *DrawTypeInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *DrawAwardInfo) Clone() *DrawAwardInfo {
	if m != nil {
		o := &DrawAwardInfo{}
		o.Id = m.Id
		o.ActivityId = m.ActivityId
		o.RewardType1 = m.RewardType1
		o.RewardValue1 = m.RewardValue1
		o.RewardNum1 = m.RewardNum1
		o.Picture1 = m.Picture1
		o.Name1 = m.Name1
		o.Battle1 = m.Battle1
		o.RewardType2 = m.RewardType2
		o.RewardValue2 = m.RewardValue2
		o.RewardNum2 = m.RewardNum2
		o.Picture2 = m.Picture2
		o.Name2 = m.Name2
		o.Battle2 = m.Battle2
		o.RewardType3 = m.RewardType3
		o.RewardValue3 = m.RewardValue3
		o.RewardNum3 = m.RewardNum3
		o.Picture3 = m.Picture3
		o.Name3 = m.Name3
		o.Battle3 = m.Battle3
		o.RewardType4 = m.RewardType4
		o.RewardValue4 = m.RewardValue4
		o.RewardNum4 = m.RewardNum4
		o.Picture4 = m.Picture4
		o.Name4 = m.Name4
		o.Battle4 = m.Battle4
		o.RewardType5 = m.RewardType5
		o.RewardValue5 = m.RewardValue5
		o.RewardNum5 = m.RewardNum5
		o.Picture5 = m.Picture5
		o.Name5 = m.Name5
		o.Battle5 = m.Battle5
		o.Percent = m.Percent
		o.RewardPercent1 = m.RewardPercent1
		o.RewardPercent2 = m.RewardPercent2
		o.RewardPercent3 = m.RewardPercent3
		o.RewardPercent4 = m.RewardPercent4
		o.RewardPercent5 = m.RewardPercent5
		return o
	}
	return nil
}

func InitDrawAwardInfo() *DrawAwardInfo {
	m := &DrawAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *DrawAwardInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *DrawProbabilityInfo) Clone() *DrawProbabilityInfo {
	if m != nil {
		o := &DrawProbabilityInfo{}
		o.Id = m.Id
		o.RewardPercentGroup = m.RewardPercentGroup
		o.Num = m.Num
		o.Percent = m.Percent
		return o
	}
	return nil
}

func InitDrawProbabilityInfo() *DrawProbabilityInfo {
	m := &DrawProbabilityInfo{}
	m.FixNilFields()
	return m
}
func (m *DrawProbabilityInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *DrawScoreInfo) Clone() *DrawScoreInfo {
	if m != nil {
		o := &DrawScoreInfo{}
		o.Id = m.Id
		o.ActivityId = m.ActivityId
		o.DrawNum = m.DrawNum
		o.AwardType1 = m.AwardType1
		o.AwardValue1 = m.AwardValue1
		o.AwardSize1 = m.AwardSize1
		o.AwardType2 = m.AwardType2
		o.AwardValue2 = m.AwardValue2
		o.AwardSize2 = m.AwardSize2
		o.AwardType3 = m.AwardType3
		o.AwardValue3 = m.AwardValue3
		o.AwardSize3 = m.AwardSize3
		return o
	}
	return nil
}

func InitDrawScoreInfo() *DrawScoreInfo {
	m := &DrawScoreInfo{}
	m.FixNilFields()
	return m
}
func (m *DrawScoreInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *DrawExchangeInfo) Clone() *DrawExchangeInfo {
	if m != nil {
		o := &DrawExchangeInfo{}
		o.Id = m.Id
		o.ActivityId = m.ActivityId
		o.Tags = m.Tags
		o.TagsName = m.TagsName
		o.Flag = m.Flag
		o.RewardType = m.RewardType
		o.RewardValue = m.RewardValue
		o.RewardNum = m.RewardNum
		o.NeedType1 = m.NeedType1
		o.NeedValue1 = m.NeedValue1
		o.NeedNum1 = m.NeedNum1
		o.NeedType2 = m.NeedType2
		o.NeedValue2 = m.NeedValue2
		o.NeedNum2 = m.NeedNum2
		o.NeedType3 = m.NeedType3
		o.NeedValue3 = m.NeedValue3
		o.NeedNum3 = m.NeedNum3
		o.NumberType = m.NumberType
		o.Number = m.Number
		return o
	}
	return nil
}

func InitDrawExchangeInfo() *DrawExchangeInfo {
	m := &DrawExchangeInfo{}
	m.FixNilFields()
	return m
}
func (m *DrawExchangeInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *DrawGiftInfo) Clone() *DrawGiftInfo {
	if m != nil {
		o := &DrawGiftInfo{}
		o.Id = m.Id
		o.ActivityId = m.ActivityId
		o.Tags = m.Tags
		o.TagsName = m.TagsName
		o.Picture = m.Picture
		o.RewardType1 = m.RewardType1
		o.RewardValue1 = m.RewardValue1
		o.RewardNum1 = m.RewardNum1
		o.RewardType2 = m.RewardType2
		o.RewardValue2 = m.RewardValue2
		o.RewardNum2 = m.RewardNum2
		o.RewardType3 = m.RewardType3
		o.RewardValue3 = m.RewardValue3
		o.RewardNum3 = m.RewardNum3
		o.RewardType4 = m.RewardType4
		o.RewardValue4 = m.RewardValue4
		o.RewardNum4 = m.RewardNum4
		o.ResetType = m.ResetType
		o.BuyNum = m.BuyNum
		o.BuyType = m.BuyType
		o.BuyValue = m.BuyValue
		o.BuySize = m.BuySize
		o.Flag = m.Flag
		o.RedpointType = m.RedpointType
		o.ProductId = m.ProductId
		o.Price = m.Price
		return o
	}
	return nil
}

func InitDrawGiftInfo() *DrawGiftInfo {
	m := &DrawGiftInfo{}
	m.FixNilFields()
	return m
}
func (m *DrawGiftInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *LuckyDrawConfig) Clone() *LuckyDrawConfig {
	if m != nil {
		o := &LuckyDrawConfig{}
		if len(m.ServerVersion) > 0 {
			o.ServerVersion = make(map[uint32]uint32, len(m.ServerVersion))
			for k, e := range m.ServerVersion {
				o.ServerVersion[k] = e
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*DrawInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		if len(m.Types) > 0 {
			o.Types = make([]*DrawTypeInfo, len(m.Types))
			for k, e := range m.Types {
				o.Types[k] = e.Clone()
			}
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*DrawAwardInfo, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.Scores) > 0 {
			o.Scores = make([]*DrawScoreInfo, len(m.Scores))
			for k, e := range m.Scores {
				o.Scores[k] = e.Clone()
			}
		}
		if len(m.Exchanges) > 0 {
			o.Exchanges = make([]*DrawExchangeInfo, len(m.Exchanges))
			for k, e := range m.Exchanges {
				o.Exchanges[k] = e.Clone()
			}
		}
		if len(m.Gifts) > 0 {
			o.Gifts = make([]*DrawGiftInfo, len(m.Gifts))
			for k, e := range m.Gifts {
				o.Gifts[k] = e.Clone()
			}
		}
		if len(m.Probs) > 0 {
			o.Probs = make([]*DrawProbabilityInfo, len(m.Probs))
			for k, e := range m.Probs {
				o.Probs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitLuckyDrawConfig() *LuckyDrawConfig {
	m := &LuckyDrawConfig{}
	m.FixNilFields()
	return m
}
func (m *LuckyDrawConfig) FixNilFields() {
	if m != nil {

		if m.ServerVersion == nil {
			m.ServerVersion = make(map[uint32]uint32)
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

		for _, itor := range m.Types {
			itor.FixNilFields()
		}

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		for _, itor := range m.Scores {
			itor.FixNilFields()
		}

		for _, itor := range m.Exchanges {
			itor.FixNilFields()
		}

		for _, itor := range m.Gifts {
			itor.FixNilFields()
		}

		for _, itor := range m.Probs {
			itor.FixNilFields()
		}

	}
}
func (m *LuckyDraw) Clone() *LuckyDraw {
	if m != nil {
		o := &LuckyDraw{}
		o.ActivityId = m.ActivityId
		o.DrawNum = m.DrawNum
		if len(m.DrawNumAwardIds) > 0 {
			o.DrawNumAwardIds = make([]uint32, len(m.DrawNumAwardIds))
			copy(o.DrawNumAwardIds, m.DrawNumAwardIds)
		}
		if len(m.DrawTargets) > 0 {
			o.DrawTargets = make(map[uint32]uint32, len(m.DrawTargets))
			for k, e := range m.DrawTargets {
				o.DrawTargets[k] = e
			}
		}
		if len(m.BuyNums) > 0 {
			o.BuyNums = make(map[uint32]*GoodsState, len(m.BuyNums))
			for k, e := range m.BuyNums {
				o.BuyNums[k] = e.Clone()
			}
		}
		if len(m.ExchangeNums) > 0 {
			o.ExchangeNums = make(map[uint32]*GoodsState, len(m.ExchangeNums))
			for k, e := range m.ExchangeNums {
				o.ExchangeNums[k] = e.Clone()
			}
		}
		o.DailyDrawNum = m.DailyDrawNum
		o.DailyDrawZtime = m.DailyDrawZtime
		o.GuaranteedDrawNum = m.GuaranteedDrawNum
		return o
	}
	return nil
}

func InitLuckyDraw() *LuckyDraw {
	m := &LuckyDraw{}
	m.FixNilFields()
	return m
}
func (m *LuckyDraw) FixNilFields() {
	if m != nil {

		if m.DrawTargets == nil {
			m.DrawTargets = make(map[uint32]uint32)
		}

		if m.BuyNums == nil {
			m.BuyNums = make(map[uint32]*GoodsState)
		}
		for _, itor := range m.BuyNums {
			itor.FixNilFields()
		}

		if m.ExchangeNums == nil {
			m.ExchangeNums = make(map[uint32]*GoodsState)
		}
		for _, itor := range m.ExchangeNums {
			itor.FixNilFields()
		}

	}
}
func (m *DiaryBook) Clone() *DiaryBook {
	if m != nil {
		o := &DiaryBook{}
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.Time = m.Time
		o.Title = m.Title.Clone()
		if len(m.Modify) > 0 {
			o.Modify = make([]byte, len(m.Modify))
			copy(o.Modify, m.Modify)
		}
		if len(m.Journals) > 0 {
			o.Journals = make([]*Journal, len(m.Journals))
			for k, e := range m.Journals {
				o.Journals[k] = e.Clone()
			}
		}
		o.Rank = m.Rank
		o.DesignationId = m.DesignationId
		return o
	}
	return nil
}

func InitDiaryBook() *DiaryBook {
	m := &DiaryBook{}
	m.FixNilFields()
	return m
}
func (m *DiaryBook) FixNilFields() {
	if m != nil {

		if m.Title == nil {
			m.Title = &DiaryTitle{}
		}
		m.Title.FixNilFields()

		for _, itor := range m.Journals {
			itor.FixNilFields()
		}

	}
}
func (m *DiaryTitle) Clone() *DiaryTitle {
	if m != nil {
		o := &DiaryTitle{}
		o.Appropriate = m.Appropriate
		o.Taboo = m.Taboo
		o.Luck = m.Luck
		o.Weather = m.Weather
		o.Mood = m.Mood
		o.Auspicious = m.Auspicious
		return o
	}
	return nil
}

func InitDiaryTitle() *DiaryTitle {
	m := &DiaryTitle{}
	m.FixNilFields()
	return m
}
func (m *DiaryTitle) FixNilFields() {
	if m != nil {

	}
}
func (m *ChatDiaryBook) Clone() *ChatDiaryBook {
	if m != nil {
		o := &ChatDiaryBook{}
		o.BaseId = m.BaseId
		o.Time = m.Time
		o.CreateTime = m.CreateTime
		o.Title = m.Title.Clone()
		if len(m.Modify) > 0 {
			o.Modify = make([]byte, len(m.Modify))
			copy(o.Modify, m.Modify)
		}
		o.Rank = m.Rank
		return o
	}
	return nil
}

func InitChatDiaryBook() *ChatDiaryBook {
	m := &ChatDiaryBook{}
	m.FixNilFields()
	return m
}
func (m *ChatDiaryBook) FixNilFields() {
	if m != nil {

		if m.Title == nil {
			m.Title = &DiaryTitle{}
		}
		m.Title.FixNilFields()

	}
}
func (m *Diary) Clone() *Diary {
	if m != nil {
		o := &Diary{}
		if len(m.Books) > 0 {
			o.Books = make(map[uint32]*DiaryBook, len(m.Books))
			for k, e := range m.Books {
				o.Books[k] = e.Clone()
			}
		}
		if len(m.DailyBooks) > 0 {
			o.DailyBooks = make(map[uint32]*DiaryBook, len(m.DailyBooks))
			for k, e := range m.DailyBooks {
				o.DailyBooks[k] = e.Clone()
			}
		}
		if len(m.ProgressAward) > 0 {
			o.ProgressAward = make(map[uint32]bool, len(m.ProgressAward))
			for k, e := range m.ProgressAward {
				o.ProgressAward[k] = e
			}
		}
		if len(m.BookAward) > 0 {
			o.BookAward = make(map[uint32]bool, len(m.BookAward))
			for k, e := range m.BookAward {
				o.BookAward[k] = e
			}
		}
		if len(m.Items) > 0 {
			o.Items = make(map[uint32]uint32, len(m.Items))
			for k, e := range m.Items {
				o.Items[k] = e
			}
		}
		if len(m.Inspirations) > 0 {
			o.Inspirations = make(map[uint32]uint32, len(m.Inspirations))
			for k, e := range m.Inspirations {
				o.Inspirations[k] = e
			}
		}
		if len(m.ShareAward) > 0 {
			o.ShareAward = make([]uint32, len(m.ShareAward))
			copy(o.ShareAward, m.ShareAward)
		}
		if len(m.Experiences) > 0 {
			o.Experiences = make([]*Experience, len(m.Experiences))
			for k, e := range m.Experiences {
				o.Experiences[k] = e.Clone()
			}
		}
		if len(m.DailyGroups) > 0 {
			o.DailyGroups = make([]uint32, len(m.DailyGroups))
			copy(o.DailyGroups, m.DailyGroups)
		}
		if len(m.WeeklyGroups) > 0 {
			o.WeeklyGroups = make([]uint32, len(m.WeeklyGroups))
			copy(o.WeeklyGroups, m.WeeklyGroups)
		}
		if len(m.ShowIds) > 0 {
			o.ShowIds = make([]uint32, len(m.ShowIds))
			copy(o.ShowIds, m.ShowIds)
		}
		o.Title = m.Title.Clone()
		o.AuspiciousTm = m.AuspiciousTm
		if len(m.ShowTitleBooks) > 0 {
			o.ShowTitleBooks = make([]*DiaryBook, len(m.ShowTitleBooks))
			for k, e := range m.ShowTitleBooks {
				o.ShowTitleBooks[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitDiary() *Diary {
	m := &Diary{}
	m.FixNilFields()
	return m
}
func (m *Diary) FixNilFields() {
	if m != nil {

		if m.Books == nil {
			m.Books = make(map[uint32]*DiaryBook)
		}
		for _, itor := range m.Books {
			itor.FixNilFields()
		}

		if m.DailyBooks == nil {
			m.DailyBooks = make(map[uint32]*DiaryBook)
		}
		for _, itor := range m.DailyBooks {
			itor.FixNilFields()
		}

		if m.ProgressAward == nil {
			m.ProgressAward = make(map[uint32]bool)
		}

		if m.BookAward == nil {
			m.BookAward = make(map[uint32]bool)
		}

		if m.Items == nil {
			m.Items = make(map[uint32]uint32)
		}

		if m.Inspirations == nil {
			m.Inspirations = make(map[uint32]uint32)
		}

		for _, itor := range m.Experiences {
			itor.FixNilFields()
		}

		if m.Title == nil {
			m.Title = &DiaryTitle{}
		}
		m.Title.FixNilFields()

		for _, itor := range m.ShowTitleBooks {
			itor.FixNilFields()
		}

	}
}
func (m *Experience) Clone() *Experience {
	if m != nil {
		o := &Experience{}
		o.Id = m.Id
		o.Status = m.Status
		return o
	}
	return nil
}

func InitExperience() *Experience {
	m := &Experience{}
	m.FixNilFields()
	return m
}
func (m *Experience) FixNilFields() {
	if m != nil {

	}
}
func (m *DesignationDiary) Clone() *DesignationDiary {
	if m != nil {
		o := &DesignationDiary{}
		o.Id = m.Id
		o.Status = m.Status
		return o
	}
	return nil
}

func InitDesignationDiary() *DesignationDiary {
	m := &DesignationDiary{}
	m.FixNilFields()
	return m
}
func (m *DesignationDiary) FixNilFields() {
	if m != nil {

	}
}
func (m *DiaryRank) Clone() *DiaryRank {
	if m != nil {
		o := &DiaryRank{}
		o.Kind = m.Kind
		o.Count = m.Count
		o.Id = m.Id
		o.Name = m.Name
		o.Book = m.Book.Clone()
		o.CreateTm = m.CreateTm
		return o
	}
	return nil
}

func InitDiaryRank() *DiaryRank {
	m := &DiaryRank{}
	m.FixNilFields()
	return m
}
func (m *DiaryRank) FixNilFields() {
	if m != nil {

		if m.Book == nil {
			m.Book = &DiaryBook{}
		}
		m.Book.FixNilFields()

	}
}
func (m *Draws) Clone() *Draws {
	if m != nil {
		o := &Draws{}
		if len(m.Draws) > 0 {
			o.Draws = make([]*Draw, len(m.Draws))
			for k, e := range m.Draws {
				o.Draws[k] = e.Clone()
			}
		}
		o.Paper = m.Paper
		return o
	}
	return nil
}

func InitDraws() *Draws {
	m := &Draws{}
	m.FixNilFields()
	return m
}
func (m *Draws) FixNilFields() {
	if m != nil {

		for _, itor := range m.Draws {
			itor.FixNilFields()
		}

	}
}
func (m *Draw) Clone() *Draw {
	if m != nil {
		o := &Draw{}
		if len(m.Ids) > 0 {
			o.Ids = make([]uint32, len(m.Ids))
			copy(o.Ids, m.Ids)
		}
		if len(m.Styles) > 0 {
			o.Styles = make([]int32, len(m.Styles))
			copy(o.Styles, m.Styles)
		}
		if len(m.Position) > 0 {
			o.Position = make([]int32, len(m.Position))
			copy(o.Position, m.Position)
		}
		return o
	}
	return nil
}

func InitDraw() *Draw {
	m := &Draw{}
	m.FixNilFields()
	return m
}
func (m *Draw) FixNilFields() {
	if m != nil {

	}
}
func (m *Soar) Clone() *Soar {
	if m != nil {
		o := &Soar{}
		o.Level = m.Level
		if len(m.AwardedPreviews) > 0 {
			o.AwardedPreviews = make([]uint32, len(m.AwardedPreviews))
			copy(o.AwardedPreviews, m.AwardedPreviews)
		}
		if len(m.AwardedStages) > 0 {
			o.AwardedStages = make([]uint32, len(m.AwardedStages))
			copy(o.AwardedStages, m.AwardedStages)
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.AwardedTaskIds) > 0 {
			o.AwardedTaskIds = make([]uint32, len(m.AwardedTaskIds))
			copy(o.AwardedTaskIds, m.AwardedTaskIds)
		}
		return o
	}
	return nil
}

func InitSoar() *Soar {
	m := &Soar{}
	m.FixNilFields()
	return m
}
func (m *Soar) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *SoarAngpow) Clone() *SoarAngpow {
	if m != nil {
		o := &SoarAngpow{}
		o.UniqueId = m.UniqueId
		o.SoarLevel = m.SoarLevel
		o.GameYear = m.GameYear
		o.Order = m.Order
		o.Time = m.Time
		o.User = m.User.Clone()
		if len(m.AngpowIds) > 0 {
			o.AngpowIds = make([]uint32, len(m.AngpowIds))
			copy(o.AngpowIds, m.AngpowIds)
		}
		return o
	}
	return nil
}

func InitSoarAngpow() *SoarAngpow {
	m := &SoarAngpow{}
	m.FixNilFields()
	return m
}
func (m *SoarAngpow) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *WorldDungeon) Clone() *WorldDungeon {
	if m != nil {
		o := &WorldDungeon{}
		if len(m.Progress) > 0 {
			o.Progress = make(map[uint32]uint32, len(m.Progress))
			for k, e := range m.Progress {
				o.Progress[k] = e
			}
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.Groups) > 0 {
			o.Groups = make(map[uint32]*WorldDungeonGroup, len(m.Groups))
			for k, e := range m.Groups {
				o.Groups[k] = e.Clone()
			}
		}
		o.ReceivedAward = m.ReceivedAward.Clone()
		o.Star = m.Star
		return o
	}
	return nil
}

func InitWorldDungeon() *WorldDungeon {
	m := &WorldDungeon{}
	m.FixNilFields()
	return m
}
func (m *WorldDungeon) FixNilFields() {
	if m != nil {

		if m.Progress == nil {
			m.Progress = make(map[uint32]uint32)
		}

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

		if m.Groups == nil {
			m.Groups = make(map[uint32]*WorldDungeonGroup)
		}
		for _, itor := range m.Groups {
			itor.FixNilFields()
		}

		if m.ReceivedAward == nil {
			m.ReceivedAward = &ReceivedAward{}
		}
		m.ReceivedAward.FixNilFields()

	}
}
func (m *SoulTour) Clone() *SoulTour {
	if m != nil {
		o := &SoulTour{}
		o.StartTime = m.StartTime
		o.LastCalcTime = m.LastCalcTime
		o.EndTime = m.EndTime
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.Level = m.Level
		o.StageLevel = m.StageLevel
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		o.BaseGroup = m.BaseGroup
		return o
	}
	return nil
}

func InitSoulTour() *SoulTour {
	m := &SoulTour{}
	m.FixNilFields()
	return m
}
func (m *SoulTour) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *WorldDungeonGroup) Clone() *WorldDungeonGroup {
	if m != nil {
		o := &WorldDungeonGroup{}
		if len(m.Orders) > 0 {
			o.Orders = make(map[uint32]uint32, len(m.Orders))
			for k, e := range m.Orders {
				o.Orders[k] = e
			}
		}
		o.Awards = m.Awards.Clone()
		return o
	}
	return nil
}

func InitWorldDungeonGroup() *WorldDungeonGroup {
	m := &WorldDungeonGroup{}
	m.FixNilFields()
	return m
}
func (m *WorldDungeonGroup) FixNilFields() {
	if m != nil {

		if m.Orders == nil {
			m.Orders = make(map[uint32]uint32)
		}

		if m.Awards == nil {
			m.Awards = &Uint32S{}
		}
		m.Awards.FixNilFields()

	}
}
func (m *GameCountState) Clone() *GameCountState {
	if m != nil {
		o := &GameCountState{}
		o.ResetTime = m.ResetTime
		o.UsedFreeCount = m.UsedFreeCount
		o.PurchasedCount = m.PurchasedCount
		return o
	}
	return nil
}

func InitGameCountState() *GameCountState {
	m := &GameCountState{}
	m.FixNilFields()
	return m
}
func (m *GameCountState) FixNilFields() {
	if m != nil {

	}
}
func (m *WorldDungeonBattle) Clone() *WorldDungeonBattle {
	if m != nil {
		o := &WorldDungeonBattle{}
		o.Result = m.Result.Clone()
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.PassFacid) > 0 {
			o.PassFacid = make([]uint32, len(m.PassFacid))
			copy(o.PassFacid, m.PassFacid)
		}
		return o
	}
	return nil
}

func InitWorldDungeonBattle() *WorldDungeonBattle {
	m := &WorldDungeonBattle{}
	m.FixNilFields()
	return m
}
func (m *WorldDungeonBattle) FixNilFields() {
	if m != nil {

		if m.Result == nil {
			m.Result = &BattleResult{}
		}
		m.Result.FixNilFields()

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *SerialChargeBox) Clone() *SerialChargeBox {
	if m != nil {
		o := &SerialChargeBox{}
		o.Group = m.Group
		if len(m.DrawIds) > 0 {
			o.DrawIds = make([]uint32, len(m.DrawIds))
			copy(o.DrawIds, m.DrawIds)
		}
		o.LeftNum = m.LeftNum
		o.TodayZtime = m.TodayZtime
		o.TodayRechargeScore = m.TodayRechargeScore
		o.TodayRechargeAmount = m.TodayRechargeAmount
		return o
	}
	return nil
}

func InitSerialChargeBox() *SerialChargeBox {
	m := &SerialChargeBox{}
	m.FixNilFields()
	return m
}
func (m *SerialChargeBox) FixNilFields() {
	if m != nil {

	}
}
func (m *SerialChargeGoods) Clone() *SerialChargeGoods {
	if m != nil {
		o := &SerialChargeGoods{}
		o.Type = m.Type
		o.BuyZtime = m.BuyZtime
		o.BuyDays = m.BuyDays
		o.AwardZtime = m.AwardZtime
		return o
	}
	return nil
}

func InitSerialChargeGoods() *SerialChargeGoods {
	m := &SerialChargeGoods{}
	m.FixNilFields()
	return m
}
func (m *SerialChargeGoods) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightSupport) Clone() *KnightSupport {
	if m != nil {
		o := &KnightSupport{}
		if len(m.Poss) > 0 {
			o.Poss = make([]*KnightSupportPos, len(m.Poss))
			for k, e := range m.Poss {
				o.Poss[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitKnightSupport() *KnightSupport {
	m := &KnightSupport{}
	m.FixNilFields()
	return m
}
func (m *KnightSupport) FixNilFields() {
	if m != nil {

		for _, itor := range m.Poss {
			itor.FixNilFields()
		}

	}
}
func (m *KnightSupportPos) Clone() *KnightSupportPos {
	if m != nil {
		o := &KnightSupportPos{}
		o.Pos = m.Pos
		o.Id = m.Id
		return o
	}
	return nil
}

func InitKnightSupportPos() *KnightSupportPos {
	m := &KnightSupportPos{}
	m.FixNilFields()
	return m
}
func (m *KnightSupportPos) FixNilFields() {
	if m != nil {

	}
}
func (m *TeamPos) Clone() *TeamPos {
	if m != nil {
		o := &TeamPos{}
		o.Id = m.Id
		o.Team = m.Team
		o.Pos = m.Pos
		return o
	}
	return nil
}

func InitTeamPos() *TeamPos {
	m := &TeamPos{}
	m.FixNilFields()
	return m
}
func (m *TeamPos) FixNilFields() {
	if m != nil {

	}
}
func (m *Furnace) Clone() *Furnace {
	if m != nil {
		o := &Furnace{}
		o.Level = m.Level
		if len(m.Tablets) > 0 {
			o.Tablets = make([]*FurnaceTablet, len(m.Tablets))
			for k, e := range m.Tablets {
				o.Tablets[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitFurnace() *Furnace {
	m := &Furnace{}
	m.FixNilFields()
	return m
}
func (m *Furnace) FixNilFields() {
	if m != nil {

		for _, itor := range m.Tablets {
			itor.FixNilFields()
		}

	}
}
func (m *FurnaceTablet) Clone() *FurnaceTablet {
	if m != nil {
		o := &FurnaceTablet{}
		o.Type = m.Type
		o.Level = m.Level
		o.Exp = m.Exp
		return o
	}
	return nil
}

func InitFurnaceTablet() *FurnaceTablet {
	m := &FurnaceTablet{}
	m.FixNilFields()
	return m
}
func (m *FurnaceTablet) FixNilFields() {
	if m != nil {

	}
}
func (m *Appearances) Clone() *Appearances {
	if m != nil {
		o := &Appearances{}
		if len(m.PreFormats) > 0 {
			o.PreFormats = make([]uint32, len(m.PreFormats))
			copy(o.PreFormats, m.PreFormats)
		}
		if len(m.Appearances) > 0 {
			o.Appearances = make(map[uint32]int64, len(m.Appearances))
			for k, e := range m.Appearances {
				o.Appearances[k] = e
			}
		}
		o.NextTimeOut = m.NextTimeOut
		return o
	}
	return nil
}

func InitAppearances() *Appearances {
	m := &Appearances{}
	m.FixNilFields()
	return m
}
func (m *Appearances) FixNilFields() {
	if m != nil {

		if m.Appearances == nil {
			m.Appearances = make(map[uint32]int64)
		}

	}
}
func (m *LeagueBossTeam) Clone() *LeagueBossTeam {
	if m != nil {
		o := &LeagueBossTeam{}
		o.TotalHarm = m.TotalHarm
		if len(m.MonsterMaxHarms) > 0 {
			o.MonsterMaxHarms = make(map[uint32]uint64, len(m.MonsterMaxHarms))
			for k, e := range m.MonsterMaxHarms {
				o.MonsterMaxHarms[k] = e
			}
		}
		return o
	}
	return nil
}

func InitLeagueBossTeam() *LeagueBossTeam {
	m := &LeagueBossTeam{}
	m.FixNilFields()
	return m
}
func (m *LeagueBossTeam) FixNilFields() {
	if m != nil {

		if m.MonsterMaxHarms == nil {
			m.MonsterMaxHarms = make(map[uint32]uint64)
		}

	}
}
func (m *LeagueBossBase) Clone() *LeagueBossBase {
	if m != nil {
		o := &LeagueBossBase{}
		o.ChallengedNum = m.ChallengedNum
		o.LeftTicketNum = m.LeftTicketNum
		o.ANum = m.ANum
		o.BNum = m.BNum
		o.CNum = m.CNum
		o.ShipLevel = m.ShipLevel
		o.TotalHarm = m.TotalHarm
		if len(m.TotalHarmAwards) > 0 {
			o.TotalHarmAwards = make([]uint32, len(m.TotalHarmAwards))
			copy(o.TotalHarmAwards, m.TotalHarmAwards)
		}
		if len(m.ShipFireAwards) > 0 {
			o.ShipFireAwards = make([]uint32, len(m.ShipFireAwards))
			copy(o.ShipFireAwards, m.ShipFireAwards)
		}
		if len(m.MonsterMaxHarms) > 0 {
			o.MonsterMaxHarms = make(map[uint32]uint64, len(m.MonsterMaxHarms))
			for k, e := range m.MonsterMaxHarms {
				o.MonsterMaxHarms[k] = e
			}
		}
		if len(m.Teams) > 0 {
			o.Teams = make(map[uint32]*LeagueBossTeam, len(m.Teams))
			for k, e := range m.Teams {
				o.Teams[k] = e.Clone()
			}
		}
		if len(m.TeamLeftChallengeNums) > 0 {
			o.TeamLeftChallengeNums = make(map[uint32]uint32, len(m.TeamLeftChallengeNums))
			for k, e := range m.TeamLeftChallengeNums {
				o.TeamLeftChallengeNums[k] = e
			}
		}
		o.InvolveLeagueId = m.InvolveLeagueId
		return o
	}
	return nil
}

func InitLeagueBossBase() *LeagueBossBase {
	m := &LeagueBossBase{}
	m.FixNilFields()
	return m
}
func (m *LeagueBossBase) FixNilFields() {
	if m != nil {

		if m.MonsterMaxHarms == nil {
			m.MonsterMaxHarms = make(map[uint32]uint64)
		}

		if m.Teams == nil {
			m.Teams = make(map[uint32]*LeagueBossTeam)
		}
		for _, itor := range m.Teams {
			itor.FixNilFields()
		}

		if m.TeamLeftChallengeNums == nil {
			m.TeamLeftChallengeNums = make(map[uint32]uint32)
		}

	}
}
func (m *LeagueBossUserShip) Clone() *LeagueBossUserShip {
	if m != nil {
		o := &LeagueBossUserShip{}
		o.Level = m.Level
		o.ANum = m.ANum
		o.BNum = m.BNum
		o.CNum = m.CNum
		o.FireNum = m.FireNum
		o.FireTotalHarm = m.FireTotalHarm
		return o
	}
	return nil
}

func InitLeagueBossUserShip() *LeagueBossUserShip {
	m := &LeagueBossUserShip{}
	m.FixNilFields()
	return m
}
func (m *LeagueBossUserShip) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueBossShip) Clone() *LeagueBossShip {
	if m != nil {
		o := &LeagueBossShip{}
		o.LeagueId = m.LeagueId
		o.LeagueName = m.LeagueName
		o.FireNum = m.FireNum
		o.FireTotalHarm = m.FireTotalHarm
		o.TotalHarm = m.TotalHarm
		return o
	}
	return nil
}

func InitLeagueBossShip() *LeagueBossShip {
	m := &LeagueBossShip{}
	m.FixNilFields()
	return m
}
func (m *LeagueBossShip) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueBossLeagueSync) Clone() *LeagueBossLeagueSync {
	if m != nil {
		o := &LeagueBossLeagueSync{}
		o.Id = m.Id
		o.Name = m.Name
		o.Level = m.Level
		o.Power = m.Power
		o.MemberCnt = m.MemberCnt
		o.TargetRoom = m.TargetRoom
		return o
	}
	return nil
}

func InitLeagueBossLeagueSync() *LeagueBossLeagueSync {
	m := &LeagueBossLeagueSync{}
	m.FixNilFields()
	return m
}
func (m *LeagueBossLeagueSync) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueBossShipFirstFireUser) Clone() *LeagueBossShipFirstFireUser {
	if m != nil {
		o := &LeagueBossShipFirstFireUser{}
		o.Uid = m.Uid
		o.Time = m.Time
		o.FireNum = m.FireNum
		return o
	}
	return nil
}

func InitLeagueBossShipFirstFireUser() *LeagueBossShipFirstFireUser {
	m := &LeagueBossShipFirstFireUser{}
	m.FixNilFields()
	return m
}
func (m *LeagueBossShipFirstFireUser) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueShipSkill) Clone() *LeagueShipSkill {
	if m != nil {
		o := &LeagueShipSkill{}
		o.Type = m.Type
		o.Level = m.Level
		o.Exp = m.Exp
		return o
	}
	return nil
}

func InitLeagueShipSkill() *LeagueShipSkill {
	m := &LeagueShipSkill{}
	m.FixNilFields()
	return m
}
func (m *LeagueShipSkill) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueShip) Clone() *LeagueShip {
	if m != nil {
		o := &LeagueShip{}
		o.Level = m.Level
		o.Exp = m.Exp
		o.TargetSkill = m.TargetSkill
		if len(m.Skills) > 0 {
			o.Skills = make([]*LeagueShipSkill, len(m.Skills))
			for k, e := range m.Skills {
				o.Skills[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitLeagueShip() *LeagueShip {
	m := &LeagueShip{}
	m.FixNilFields()
	return m
}
func (m *LeagueShip) FixNilFields() {
	if m != nil {

		for _, itor := range m.Skills {
			itor.FixNilFields()
		}

	}
}
func (m *MessageBoard) Clone() *MessageBoard {
	if m != nil {
		o := &MessageBoard{}
		o.Type = m.Type
		o.Value = m.Value
		if len(m.Texts) > 0 {
			o.Texts = make([]*MessageText, len(m.Texts))
			for k, e := range m.Texts {
				o.Texts[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitMessageBoard() *MessageBoard {
	m := &MessageBoard{}
	m.FixNilFields()
	return m
}
func (m *MessageBoard) FixNilFields() {
	if m != nil {

		for _, itor := range m.Texts {
			itor.FixNilFields()
		}

	}
}
func (m *MessageText) Clone() *MessageText {
	if m != nil {
		o := &MessageText{}
		o.Id = m.Id
		o.Content = m.Content
		o.WriteTime = m.WriteTime
		o.CheckTime = m.CheckTime
		o.User = m.User.Clone()
		o.LikedNum = m.LikedNum
		if len(m.Extend) > 0 {
			o.Extend = make([]byte, len(m.Extend))
			copy(o.Extend, m.Extend)
		}
		return o
	}
	return nil
}

func InitMessageText() *MessageText {
	m := &MessageText{}
	m.FixNilFields()
	return m
}
func (m *MessageText) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *KnightActivityInfo) Clone() *KnightActivityInfo {
	if m != nil {
		o := &KnightActivityInfo{}
		o.Id = m.Id
		o.IconEnter = m.IconEnter
		o.NameEnter = m.NameEnter
		o.ActivityGroup = m.ActivityGroup
		o.SubactivityType = m.SubactivityType
		o.Name = m.Name
		o.ActivityOpen = m.ActivityOpen
		o.ActivityClose = m.ActivityClose
		o.ShowType_1 = m.ShowType_1
		o.ShowValue_1 = m.ShowValue_1
		o.ShowType_2 = m.ShowType_2
		o.ShowValue_2 = m.ShowValue_2
		o.Bg = m.Bg
		o.Picture = m.Picture
		o.Title = m.Title
		o.Des = m.Des
		o.Icon = m.Icon
		o.Flag = m.Flag
		o.Priority = m.Priority
		o.TimeType = m.TimeType
		o.ForceEnd = m.ForceEnd
		return o
	}
	return nil
}

func InitKnightActivityInfo() *KnightActivityInfo {
	m := &KnightActivityInfo{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityCallInfo) Clone() *KnightActivityCallInfo {
	if m != nil {
		o := &KnightActivityCallInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.ChooseGroup = m.ChooseGroup
		o.ThemeKnight = m.ThemeKnight
		o.KnightDes = m.KnightDes
		o.ProbGroup = m.ProbGroup
		o.ProbOrigin = m.ProbOrigin
		o.ProbAdd = m.ProbAdd
		o.BigGroup = m.BigGroup
		o.AverageGroup = m.AverageGroup
		o.CostType1 = m.CostType1
		o.CostValue1 = m.CostValue1
		o.CostSize1 = m.CostSize1
		o.CostType2 = m.CostType2
		o.CostValue2 = m.CostValue2
		o.CostSize2 = m.CostSize2
		o.RewardType = m.RewardType
		o.RewardValue = m.RewardValue
		o.RewardSize = m.RewardSize
		o.ThemeProb = m.ThemeProb
		return o
	}
	return nil
}

func InitKnightActivityCallInfo() *KnightActivityCallInfo {
	m := &KnightActivityCallInfo{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityCallInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityContentInfo) Clone() *KnightActivityContentInfo {
	if m != nil {
		o := &KnightActivityContentInfo{}
		o.Id = m.Id
		o.Group = m.Group
		o.ChooseGroup = m.ChooseGroup
		o.ShowType = m.ShowType
		o.ShowValue = m.ShowValue
		o.AwardType = m.AwardType
		o.AwardValue = m.AwardValue
		o.AwardSize = m.AwardSize
		o.Prob = m.Prob
		o.ProbShow = m.ProbShow
		return o
	}
	return nil
}

func InitKnightActivityContentInfo() *KnightActivityContentInfo {
	m := &KnightActivityContentInfo{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityContentInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityChooseInfo) Clone() *KnightActivityChooseInfo {
	if m != nil {
		o := &KnightActivityChooseInfo{}
		o.Id = m.Id
		o.Group = m.Group
		o.AwardType = m.AwardType
		o.AwardValue = m.AwardValue
		o.AwardSize = m.AwardSize
		o.Main = m.Main
		o.ThemeKnight = m.ThemeKnight
		o.KnightDes = m.KnightDes
		o.MainPic = m.MainPic
		return o
	}
	return nil
}

func InitKnightActivityChooseInfo() *KnightActivityChooseInfo {
	m := &KnightActivityChooseInfo{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityChooseInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityProbInfo) Clone() *KnightActivityProbInfo {
	if m != nil {
		o := &KnightActivityProbInfo{}
		o.Id = m.Id
		o.Group = m.Group
		o.Number = m.Number
		o.Prob = m.Prob
		return o
	}
	return nil
}

func InitKnightActivityProbInfo() *KnightActivityProbInfo {
	m := &KnightActivityProbInfo{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityProbInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityCallShopInfo) Clone() *KnightActivityCallShopInfo {
	if m != nil {
		o := &KnightActivityCallShopInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.Title = m.Title
		o.Bg = m.Bg
		o.AwardType = m.AwardType
		o.AwardValue = m.AwardValue
		o.AwardSize = m.AwardSize
		o.LimitType = m.LimitType
		o.LimitNum = m.LimitNum
		o.CostType = m.CostType
		o.CostValue = m.CostValue
		o.CostSize = m.CostSize
		o.Tag = m.Tag
		return o
	}
	return nil
}

func InitKnightActivityCallShopInfo() *KnightActivityCallShopInfo {
	m := &KnightActivityCallShopInfo{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityCallShopInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityGiftInfo) Clone() *KnightActivityGiftInfo {
	if m != nil {
		o := &KnightActivityGiftInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.Icon = m.Icon
		o.AwardType1 = m.AwardType1
		o.AwardValue1 = m.AwardValue1
		o.AwardSize1 = m.AwardSize1
		o.AwardType2 = m.AwardType2
		o.AwardValue2 = m.AwardValue2
		o.AwardSize2 = m.AwardSize2
		o.AwardType3 = m.AwardType3
		o.AwardValue3 = m.AwardValue3
		o.AwardSize3 = m.AwardSize3
		o.LimitType = m.LimitType
		o.LimitNum = m.LimitNum
		o.Type = m.Type
		o.CostType = m.CostType
		o.CostValue = m.CostValue
		o.CostSize = m.CostSize
		o.OriginalPrice = m.OriginalPrice
		o.Discount = m.Discount
		o.PrivilegeTag = m.PrivilegeTag
		o.Redpoint = m.Redpoint
		o.ProductId = m.ProductId
		o.Price = m.Price
		return o
	}
	return nil
}

func InitKnightActivityGiftInfo() *KnightActivityGiftInfo {
	m := &KnightActivityGiftInfo{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityGiftInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityAwardInfo) Clone() *KnightActivityAwardInfo {
	if m != nil {
		o := &KnightActivityAwardInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.Level = m.Level
		o.LevelNext = m.LevelNext
		o.LevelName = m.LevelName
		o.Des = m.Des
		o.AwardType = m.AwardType
		o.AwardValue = m.AwardValue
		o.AwardSize = m.AwardSize
		o.Prob = m.Prob
		o.IsPrize = m.IsPrize
		o.PrizePicture = m.PrizePicture
		o.CostType = m.CostType
		o.CostValue = m.CostValue
		o.CostSize = m.CostSize
		return o
	}
	return nil
}

func InitKnightActivityAwardInfo() *KnightActivityAwardInfo {
	m := &KnightActivityAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityAwardInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityActiveInfo) Clone() *KnightActivityActiveInfo {
	if m != nil {
		o := &KnightActivityActiveInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.Title = m.Title
		o.Bg = m.Bg
		o.Name = m.Name
		o.Event = m.Event
		o.Value = m.Value
		o.Progress = m.Progress
		o.AwardType1 = m.AwardType1
		o.AwardValue1 = m.AwardValue1
		o.AwardSize1 = m.AwardSize1
		o.AwardType2 = m.AwardType2
		o.AwardValue2 = m.AwardValue2
		o.AwardSize2 = m.AwardSize2
		o.AwardType3 = m.AwardType3
		o.AwardValue3 = m.AwardValue3
		o.AwardSize3 = m.AwardSize3
		o.Jump = m.Jump
		return o
	}
	return nil
}

func InitKnightActivityActiveInfo() *KnightActivityActiveInfo {
	m := &KnightActivityActiveInfo{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityActiveInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityBossTimeInfo) Clone() *KnightActivityBossTimeInfo {
	if m != nil {
		o := &KnightActivityBossTimeInfo{}
		o.Id = m.Id
		o.RelateGroup = m.RelateGroup
		o.BossGroup = m.BossGroup
		o.OpenTime = m.OpenTime
		o.StayTime = m.StayTime
		o.ActId = m.ActId
		return o
	}
	return nil
}

func InitKnightActivityBossTimeInfo() *KnightActivityBossTimeInfo {
	m := &KnightActivityBossTimeInfo{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityBossTimeInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityConfig) Clone() *KnightActivityConfig {
	if m != nil {
		o := &KnightActivityConfig{}
		if len(m.ServerVersion) > 0 {
			o.ServerVersion = make(map[uint32]uint32, len(m.ServerVersion))
			for k, e := range m.ServerVersion {
				o.ServerVersion[k] = e
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*KnightActivityInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		if len(m.Calls) > 0 {
			o.Calls = make([]*KnightActivityCallInfo, len(m.Calls))
			for k, e := range m.Calls {
				o.Calls[k] = e.Clone()
			}
		}
		if len(m.Contents) > 0 {
			o.Contents = make([]*KnightActivityContentInfo, len(m.Contents))
			for k, e := range m.Contents {
				o.Contents[k] = e.Clone()
			}
		}
		if len(m.Shops) > 0 {
			o.Shops = make([]*KnightActivityCallShopInfo, len(m.Shops))
			for k, e := range m.Shops {
				o.Shops[k] = e.Clone()
			}
		}
		if len(m.Gifts) > 0 {
			o.Gifts = make([]*KnightActivityGiftInfo, len(m.Gifts))
			for k, e := range m.Gifts {
				o.Gifts[k] = e.Clone()
			}
		}
		if len(m.Probs) > 0 {
			o.Probs = make([]*KnightActivityProbInfo, len(m.Probs))
			for k, e := range m.Probs {
				o.Probs[k] = e.Clone()
			}
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*KnightActivityAwardInfo, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.Actives) > 0 {
			o.Actives = make([]*KnightActivityActiveInfo, len(m.Actives))
			for k, e := range m.Actives {
				o.Actives[k] = e.Clone()
			}
		}
		if len(m.Chooses) > 0 {
			o.Chooses = make([]*KnightActivityChooseInfo, len(m.Chooses))
			for k, e := range m.Chooses {
				o.Chooses[k] = e.Clone()
			}
		}
		if len(m.Bosss) > 0 {
			o.Bosss = make([]*KnightActivityBossTimeInfo, len(m.Bosss))
			for k, e := range m.Bosss {
				o.Bosss[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitKnightActivityConfig() *KnightActivityConfig {
	m := &KnightActivityConfig{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityConfig) FixNilFields() {
	if m != nil {

		if m.ServerVersion == nil {
			m.ServerVersion = make(map[uint32]uint32)
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

		for _, itor := range m.Calls {
			itor.FixNilFields()
		}

		for _, itor := range m.Contents {
			itor.FixNilFields()
		}

		for _, itor := range m.Shops {
			itor.FixNilFields()
		}

		for _, itor := range m.Gifts {
			itor.FixNilFields()
		}

		for _, itor := range m.Probs {
			itor.FixNilFields()
		}

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		for _, itor := range m.Actives {
			itor.FixNilFields()
		}

		for _, itor := range m.Chooses {
			itor.FixNilFields()
		}

		for _, itor := range m.Bosss {
			itor.FixNilFields()
		}

	}
}
func (m *KnightActivity) Clone() *KnightActivity {
	if m != nil {
		o := &KnightActivity{}
		o.GroupId = m.GroupId
		o.Call = m.Call.Clone()
		o.Gift = m.Gift.Clone()
		o.Active = m.Active.Clone()
		o.Boss = m.Boss.Clone()
		return o
	}
	return nil
}

func InitKnightActivity() *KnightActivity {
	m := &KnightActivity{}
	m.FixNilFields()
	return m
}
func (m *KnightActivity) FixNilFields() {
	if m != nil {

		if m.Call == nil {
			m.Call = &KnightActivityCall{}
		}
		m.Call.FixNilFields()

		if m.Gift == nil {
			m.Gift = &KnightActivityGift{}
		}
		m.Gift.FixNilFields()

		if m.Active == nil {
			m.Active = &KnightActivityActive{}
		}
		m.Active.FixNilFields()

		if m.Boss == nil {
			m.Boss = &KnightActivityBoss{}
		}
		m.Boss.FixNilFields()

	}
}
func (m *KnightActivityCall) Clone() *KnightActivityCall {
	if m != nil {
		o := &KnightActivityCall{}
		o.CallNum = m.CallNum
		o.ResetTime = m.ResetTime
		if len(m.BuyNums) > 0 {
			o.BuyNums = make([]*Goods, len(m.BuyNums))
			for k, e := range m.BuyNums {
				o.BuyNums[k] = e.Clone()
			}
		}
		o.ChooseId = m.ChooseId
		return o
	}
	return nil
}

func InitKnightActivityCall() *KnightActivityCall {
	m := &KnightActivityCall{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityCall) FixNilFields() {
	if m != nil {

		for _, itor := range m.BuyNums {
			itor.FixNilFields()
		}

	}
}
func (m *KnightActivityGift) Clone() *KnightActivityGift {
	if m != nil {
		o := &KnightActivityGift{}
		o.ResetTime = m.ResetTime
		if len(m.BuyNums) > 0 {
			o.BuyNums = make([]*Goods, len(m.BuyNums))
			for k, e := range m.BuyNums {
				o.BuyNums[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitKnightActivityGift() *KnightActivityGift {
	m := &KnightActivityGift{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityGift) FixNilFields() {
	if m != nil {

		for _, itor := range m.BuyNums {
			itor.FixNilFields()
		}

	}
}
func (m *KnightActivityActive) Clone() *KnightActivityActive {
	if m != nil {
		o := &KnightActivityActive{}
		o.ResetTime = m.ResetTime
		if len(m.TaskAwarded) > 0 {
			o.TaskAwarded = make([]uint32, len(m.TaskAwarded))
			copy(o.TaskAwarded, m.TaskAwarded)
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		o.Level = m.Level
		if len(m.Awards) > 0 {
			o.Awards = make(map[uint32]uint32, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e
			}
		}
		o.Score = m.Score
		return o
	}
	return nil
}

func InitKnightActivityActive() *KnightActivityActive {
	m := &KnightActivityActive{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityActive) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

		if m.Awards == nil {
			m.Awards = make(map[uint32]uint32)
		}

	}
}
func (m *KnightActivityBossFragment) Clone() *KnightActivityBossFragment {
	if m != nil {
		o := &KnightActivityBossFragment{}
		o.FragmentId = m.FragmentId
		o.FragmentStatus = m.FragmentStatus
		return o
	}
	return nil
}

func InitKnightActivityBossFragment() *KnightActivityBossFragment {
	m := &KnightActivityBossFragment{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityBossFragment) FixNilFields() {
	if m != nil {

	}
}
func (m *KnightActivityBossData) Clone() *KnightActivityBossData {
	if m != nil {
		o := &KnightActivityBossData{}
		o.BossId = m.BossId
		if len(m.ScoreAwarded) > 0 {
			o.ScoreAwarded = make([]uint32, len(m.ScoreAwarded))
			copy(o.ScoreAwarded, m.ScoreAwarded)
		}
		o.ChallengeTime = m.ChallengeTime
		o.MaxHarm = m.MaxHarm
		if len(m.Fragments) > 0 {
			o.Fragments = make([]*KnightActivityBossFragment, len(m.Fragments))
			for k, e := range m.Fragments {
				o.Fragments[k] = e.Clone()
			}
		}
		o.StoryStatus = m.StoryStatus
		return o
	}
	return nil
}

func InitKnightActivityBossData() *KnightActivityBossData {
	m := &KnightActivityBossData{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityBossData) FixNilFields() {
	if m != nil {

		for _, itor := range m.Fragments {
			itor.FixNilFields()
		}

	}
}
func (m *KnightActivityBoss) Clone() *KnightActivityBoss {
	if m != nil {
		o := &KnightActivityBoss{}
		o.ResetTime = m.ResetTime
		if len(m.BossData) > 0 {
			o.BossData = make([]*KnightActivityBossData, len(m.BossData))
			for k, e := range m.BossData {
				o.BossData[k] = e.Clone()
			}
		}
		if len(m.Scores) > 0 {
			o.Scores = make(map[uint32]uint32, len(m.Scores))
			for k, e := range m.Scores {
				o.Scores[k] = e
			}
		}
		o.ChallengeCnt = m.ChallengeCnt
		return o
	}
	return nil
}

func InitKnightActivityBoss() *KnightActivityBoss {
	m := &KnightActivityBoss{}
	m.FixNilFields()
	return m
}
func (m *KnightActivityBoss) FixNilFields() {
	if m != nil {

		for _, itor := range m.BossData {
			itor.FixNilFields()
		}

		if m.Scores == nil {
			m.Scores = make(map[uint32]uint32)
		}

	}
}
func (m *SurpriseBoxHelpUser) Clone() *SurpriseBoxHelpUser {
	if m != nil {
		o := &SurpriseBoxHelpUser{}
		o.Uid = m.Uid
		o.MessageId = m.MessageId
		o.AwardId = m.AwardId
		return o
	}
	return nil
}

func InitSurpriseBoxHelpUser() *SurpriseBoxHelpUser {
	m := &SurpriseBoxHelpUser{}
	m.FixNilFields()
	return m
}
func (m *SurpriseBoxHelpUser) FixNilFields() {
	if m != nil {

	}
}
func (m *SurpriseBox) Clone() *SurpriseBox {
	if m != nil {
		o := &SurpriseBox{}
		o.Id = m.Id
		o.InfoId = m.InfoId
		o.Uid = m.Uid
		o.HelpNum = m.HelpNum
		o.DropTime = m.DropTime
		o.EndTime = m.EndTime
		o.OpenTime = m.OpenTime
		o.Received = m.Received
		if len(m.HelpListLuck) > 0 {
			o.HelpListLuck = make([]*SurpriseBoxHelpUser, len(m.HelpListLuck))
			for k, e := range m.HelpListLuck {
				o.HelpListLuck[k] = e.Clone()
			}
		}
		if len(m.HelpList) > 0 {
			o.HelpList = make([]*SurpriseBoxHelpUser, len(m.HelpList))
			for k, e := range m.HelpList {
				o.HelpList[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitSurpriseBox() *SurpriseBox {
	m := &SurpriseBox{}
	m.FixNilFields()
	return m
}
func (m *SurpriseBox) FixNilFields() {
	if m != nil {

		for _, itor := range m.HelpListLuck {
			itor.FixNilFields()
		}

		for _, itor := range m.HelpList {
			itor.FixNilFields()
		}

	}
}
func (m *SurpriseBoxBrief) Clone() *SurpriseBoxBrief {
	if m != nil {
		o := &SurpriseBoxBrief{}
		o.Id = m.Id
		o.EndTime = m.EndTime
		o.Uid = m.Uid
		return o
	}
	return nil
}

func InitSurpriseBoxBrief() *SurpriseBoxBrief {
	m := &SurpriseBoxBrief{}
	m.FixNilFields()
	return m
}
func (m *SurpriseBoxBrief) FixNilFields() {
	if m != nil {

	}
}
func (m *SimpleUserSnap) Clone() *SimpleUserSnap {
	if m != nil {
		o := &SimpleUserSnap{}
		o.Id = m.Id
		o.Comment = m.Comment
		o.CreatedAt = m.CreatedAt
		return o
	}
	return nil
}

func InitSimpleUserSnap() *SimpleUserSnap {
	m := &SimpleUserSnap{}
	m.FixNilFields()
	return m
}
func (m *SimpleUserSnap) FixNilFields() {
	if m != nil {

	}
}
func (m *RelaxedTask) Clone() *RelaxedTask {
	if m != nil {
		o := &RelaxedTask{}
		o.Id = m.Id
		o.State = m.State
		o.Time = m.Time
		return o
	}
	return nil
}

func InitRelaxedTask() *RelaxedTask {
	m := &RelaxedTask{}
	m.FixNilFields()
	return m
}
func (m *RelaxedTask) FixNilFields() {
	if m != nil {

	}
}
func (m *PowerAttrMainRole) Clone() *PowerAttrMainRole {
	if m != nil {
		o := &PowerAttrMainRole{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrMainRole() *PowerAttrMainRole {
	m := &PowerAttrMainRole{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrMainRole) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

	}
}
func (m *PowerAttrKnight) Clone() *PowerAttrKnight {
	if m != nil {
		o := &PowerAttrKnight{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrKnight() *PowerAttrKnight {
	m := &PowerAttrKnight{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrKnight) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

	}
}
func (m *PowerAttrKnightSupportPos) Clone() *PowerAttrKnightSupportPos {
	if m != nil {
		o := &PowerAttrKnightSupportPos{}
		o.Pos = m.Pos
		o.Id = m.Id
		o.Star = m.Star
		return o
	}
	return nil
}

func InitPowerAttrKnightSupportPos() *PowerAttrKnightSupportPos {
	m := &PowerAttrKnightSupportPos{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrKnightSupportPos) FixNilFields() {
	if m != nil {

	}
}
func (m *PowerAttrKnightSupportFormation) Clone() *PowerAttrKnightSupportFormation {
	if m != nil {
		o := &PowerAttrKnightSupportFormation{}
		o.Id = m.Id
		if len(m.Poss) > 0 {
			o.Poss = make([]*PowerAttrKnightSupportPos, len(m.Poss))
			for k, e := range m.Poss {
				o.Poss[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrKnightSupportFormation() *PowerAttrKnightSupportFormation {
	m := &PowerAttrKnightSupportFormation{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrKnightSupportFormation) FixNilFields() {
	if m != nil {

		for _, itor := range m.Poss {
			itor.FixNilFields()
		}

	}
}
func (m *PowerAttrKnightSupport) Clone() *PowerAttrKnightSupport {
	if m != nil {
		o := &PowerAttrKnightSupport{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		if len(m.Formations) > 0 {
			o.Formations = make([]*PowerAttrKnightSupportFormation, len(m.Formations))
			for k, e := range m.Formations {
				o.Formations[k] = e.Clone()
			}
		}
		if len(m.DigestionAttrs) > 0 {
			o.DigestionAttrs = make(map[uint32]*Int64S, len(m.DigestionAttrs))
			for k, e := range m.DigestionAttrs {
				o.DigestionAttrs[k] = e.Clone()
			}
		}
		o.Digestion = m.Digestion.Clone()
		return o
	}
	return nil
}

func InitPowerAttrKnightSupport() *PowerAttrKnightSupport {
	m := &PowerAttrKnightSupport{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrKnightSupport) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

		for _, itor := range m.Formations {
			itor.FixNilFields()
		}

		if m.DigestionAttrs == nil {
			m.DigestionAttrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.DigestionAttrs {
			itor.FixNilFields()
		}

		if m.Digestion == nil {
			m.Digestion = &Digestion{}
		}
		m.Digestion.FixNilFields()

	}
}
func (m *PowerAttrHandbook) Clone() *PowerAttrHandbook {
	if m != nil {
		o := &PowerAttrHandbook{}
		if len(m.Ids) > 0 {
			o.Ids = make([]uint32, len(m.Ids))
			copy(o.Ids, m.Ids)
		}
		o.Level = m.Level
		return o
	}
	return nil
}

func InitPowerAttrHandbook() *PowerAttrHandbook {
	m := &PowerAttrHandbook{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrHandbook) FixNilFields() {
	if m != nil {

	}
}
func (m *PowerAttrEquipment) Clone() *PowerAttrEquipment {
	if m != nil {
		o := &PowerAttrEquipment{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrEquipment() *PowerAttrEquipment {
	m := &PowerAttrEquipment{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrEquipment) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

	}
}
func (m *PowerAttrSkill) Clone() *PowerAttrSkill {
	if m != nil {
		o := &PowerAttrSkill{}
		if len(m.Skills) > 0 {
			o.Skills = make(map[uint32]uint32, len(m.Skills))
			for k, e := range m.Skills {
				o.Skills[k] = e
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrSkill() *PowerAttrSkill {
	m := &PowerAttrSkill{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrSkill) FixNilFields() {
	if m != nil {

		if m.Skills == nil {
			m.Skills = make(map[uint32]uint32)
		}

	}
}
func (m *PowerAttrPill) Clone() *PowerAttrPill {
	if m != nil {
		o := &PowerAttrPill{}
		if len(m.Taken) > 0 {
			o.Taken = make(map[uint32]uint32, len(m.Taken))
			for k, e := range m.Taken {
				o.Taken[k] = e
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrPill() *PowerAttrPill {
	m := &PowerAttrPill{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrPill) FixNilFields() {
	if m != nil {

		if m.Taken == nil {
			m.Taken = make(map[uint32]uint32)
		}

	}
}
func (m *PowerAttrThrone) Clone() *PowerAttrThrone {
	if m != nil {
		o := &PowerAttrThrone{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrThrone() *PowerAttrThrone {
	m := &PowerAttrThrone{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrThrone) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

	}
}
func (m *PowerAttrFashion) Clone() *PowerAttrFashion {
	if m != nil {
		o := &PowerAttrFashion{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrFashion() *PowerAttrFashion {
	m := &PowerAttrFashion{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrFashion) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

	}
}
func (m *PowerAttrMeridian) Clone() *PowerAttrMeridian {
	if m != nil {
		o := &PowerAttrMeridian{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrMeridian() *PowerAttrMeridian {
	m := &PowerAttrMeridian{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrMeridian) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

	}
}
func (m *PowerAttrFurnace) Clone() *PowerAttrFurnace {
	if m != nil {
		o := &PowerAttrFurnace{}
		o.Data = m.Data.Clone()
		return o
	}
	return nil
}

func InitPowerAttrFurnace() *PowerAttrFurnace {
	m := &PowerAttrFurnace{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrFurnace) FixNilFields() {
	if m != nil {

		if m.Data == nil {
			m.Data = &Furnace{}
		}
		m.Data.FixNilFields()

	}
}
func (m *PowerAttrSwordForging) Clone() *PowerAttrSwordForging {
	if m != nil {
		o := &PowerAttrSwordForging{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		o.Data = m.Data.Clone()
		return o
	}
	return nil
}

func InitPowerAttrSwordForging() *PowerAttrSwordForging {
	m := &PowerAttrSwordForging{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrSwordForging) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

		if m.Data == nil {
			m.Data = &SwordForgingBase{}
		}
		m.Data.FixNilFields()

	}
}
func (m *PowerAttrRacialArticle) Clone() *PowerAttrRacialArticle {
	if m != nil {
		o := &PowerAttrRacialArticle{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		if len(m.Data) > 0 {
			o.Data = make([]*RacialArticle, len(m.Data))
			for k, e := range m.Data {
				o.Data[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrRacialArticle() *PowerAttrRacialArticle {
	m := &PowerAttrRacialArticle{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrRacialArticle) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

		for _, itor := range m.Data {
			itor.FixNilFields()
		}

	}
}
func (m *PowerAttrRules) Clone() *PowerAttrRules {
	if m != nil {
		o := &PowerAttrRules{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		if len(m.Data) > 0 {
			o.Data = make([]*Rules, len(m.Data))
			for k, e := range m.Data {
				o.Data[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrRules() *PowerAttrRules {
	m := &PowerAttrRules{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrRules) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

		for _, itor := range m.Data {
			itor.FixNilFields()
		}

	}
}
func (m *PowerAttrKnightSkins) Clone() *PowerAttrKnightSkins {
	if m != nil {
		o := &PowerAttrKnightSkins{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		if len(m.Data) > 0 {
			o.Data = make(map[uint32]uint32, len(m.Data))
			for k, e := range m.Data {
				o.Data[k] = e
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrKnightSkins() *PowerAttrKnightSkins {
	m := &PowerAttrKnightSkins{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrKnightSkins) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

		if m.Data == nil {
			m.Data = make(map[uint32]uint32)
		}

	}
}
func (m *PowerAttrPrinciplePractice) Clone() *PowerAttrPrinciplePractice {
	if m != nil {
		o := &PowerAttrPrinciplePractice{}
		if len(m.Attrs) > 0 {
			o.Attrs = make(map[uint32]*Int64S, len(m.Attrs))
			for k, e := range m.Attrs {
				o.Attrs[k] = e.Clone()
			}
		}
		if len(m.Data) > 0 {
			o.Data = make([]*PrinciplePracticeGroup, len(m.Data))
			for k, e := range m.Data {
				o.Data[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPowerAttrPrinciplePractice() *PowerAttrPrinciplePractice {
	m := &PowerAttrPrinciplePractice{}
	m.FixNilFields()
	return m
}
func (m *PowerAttrPrinciplePractice) FixNilFields() {
	if m != nil {

		if m.Attrs == nil {
			m.Attrs = make(map[uint32]*Int64S)
		}
		for _, itor := range m.Attrs {
			itor.FixNilFields()
		}

		for _, itor := range m.Data {
			itor.FixNilFields()
		}

	}
}
func (m *PowerAttr) Clone() *PowerAttr {
	if m != nil {
		o := &PowerAttr{}
		o.MainRole = m.MainRole.Clone()
		o.Knight = m.Knight.Clone()
		o.KnightSupport = m.KnightSupport.Clone()
		o.Handbook = m.Handbook.Clone()
		o.Equipment = m.Equipment.Clone()
		o.Skill = m.Skill.Clone()
		o.Pill = m.Pill.Clone()
		o.Throne = m.Throne.Clone()
		o.Fashion = m.Fashion.Clone()
		o.Meridian = m.Meridian.Clone()
		o.Furnace = m.Furnace.Clone()
		o.SwordForging = m.SwordForging.Clone()
		o.RacialArticle = m.RacialArticle.Clone()
		o.Rules = m.Rules.Clone()
		o.KnightSkins = m.KnightSkins.Clone()
		o.PrinciplePractice = m.PrinciplePractice.Clone()
		return o
	}
	return nil
}

func InitPowerAttr() *PowerAttr {
	m := &PowerAttr{}
	m.FixNilFields()
	return m
}
func (m *PowerAttr) FixNilFields() {
	if m != nil {

		if m.MainRole == nil {
			m.MainRole = &PowerAttrMainRole{}
		}
		m.MainRole.FixNilFields()

		if m.Knight == nil {
			m.Knight = &PowerAttrKnight{}
		}
		m.Knight.FixNilFields()

		if m.KnightSupport == nil {
			m.KnightSupport = &PowerAttrKnightSupport{}
		}
		m.KnightSupport.FixNilFields()

		if m.Handbook == nil {
			m.Handbook = &PowerAttrHandbook{}
		}
		m.Handbook.FixNilFields()

		if m.Equipment == nil {
			m.Equipment = &PowerAttrEquipment{}
		}
		m.Equipment.FixNilFields()

		if m.Skill == nil {
			m.Skill = &PowerAttrSkill{}
		}
		m.Skill.FixNilFields()

		if m.Pill == nil {
			m.Pill = &PowerAttrPill{}
		}
		m.Pill.FixNilFields()

		if m.Throne == nil {
			m.Throne = &PowerAttrThrone{}
		}
		m.Throne.FixNilFields()

		if m.Fashion == nil {
			m.Fashion = &PowerAttrFashion{}
		}
		m.Fashion.FixNilFields()

		if m.Meridian == nil {
			m.Meridian = &PowerAttrMeridian{}
		}
		m.Meridian.FixNilFields()

		if m.Furnace == nil {
			m.Furnace = &PowerAttrFurnace{}
		}
		m.Furnace.FixNilFields()

		if m.SwordForging == nil {
			m.SwordForging = &PowerAttrSwordForging{}
		}
		m.SwordForging.FixNilFields()

		if m.RacialArticle == nil {
			m.RacialArticle = &PowerAttrRacialArticle{}
		}
		m.RacialArticle.FixNilFields()

		if m.Rules == nil {
			m.Rules = &PowerAttrRules{}
		}
		m.Rules.FixNilFields()

		if m.KnightSkins == nil {
			m.KnightSkins = &PowerAttrKnightSkins{}
		}
		m.KnightSkins.FixNilFields()

		if m.PrinciplePractice == nil {
			m.PrinciplePractice = &PowerAttrPrinciplePractice{}
		}
		m.PrinciplePractice.FixNilFields()

	}
}
func (m *Instructions) Clone() *Instructions {
	if m != nil {
		o := &Instructions{}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.Awarded) > 0 {
			o.Awarded = make([]uint32, len(m.Awarded))
			copy(o.Awarded, m.Awarded)
		}
		if len(m.PickTasks) > 0 {
			o.PickTasks = make([]uint32, len(m.PickTasks))
			copy(o.PickTasks, m.PickTasks)
		}
		return o
	}
	return nil
}

func InitInstructions() *Instructions {
	m := &Instructions{}
	m.FixNilFields()
	return m
}
func (m *Instructions) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *LuckyBagInfo) Clone() *LuckyBagInfo {
	if m != nil {
		o := &LuckyBagInfo{}
		o.Id = m.Id
		o.Type = m.Type
		o.Name = m.Name
		o.Icon = m.Icon
		o.StartTitle = m.StartTitle
		o.StartDes = m.StartDes
		o.OpenTime = m.OpenTime
		o.CloseTime = m.CloseTime
		o.StartMoment = m.StartMoment
		o.LastTime = m.LastTime
		o.WinTime = m.WinTime
		o.NumberHigh = m.NumberHigh
		o.NumberLow = m.NumberLow
		o.RelateGroup = m.RelateGroup
		return o
	}
	return nil
}

func InitLuckyBagInfo() *LuckyBagInfo {
	m := &LuckyBagInfo{}
	m.FixNilFields()
	return m
}
func (m *LuckyBagInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *LuckyBagTypeInfo) Clone() *LuckyBagTypeInfo {
	if m != nil {
		o := &LuckyBagTypeInfo{}
		o.Id = m.Id
		o.EventId = m.EventId
		o.BagType = m.BagType
		o.Icon = m.Icon
		o.Prob = m.Prob
		o.Group = m.Group
		return o
	}
	return nil
}

func InitLuckyBagTypeInfo() *LuckyBagTypeInfo {
	m := &LuckyBagTypeInfo{}
	m.FixNilFields()
	return m
}
func (m *LuckyBagTypeInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *LuckyBagContentInfo) Clone() *LuckyBagContentInfo {
	if m != nil {
		o := &LuckyBagContentInfo{}
		o.Id = m.Id
		o.Group = m.Group
		o.AwardType = m.AwardType
		o.AwardValue = m.AwardValue
		o.AwardSize = m.AwardSize
		o.Prob = m.Prob
		return o
	}
	return nil
}

func InitLuckyBagContentInfo() *LuckyBagContentInfo {
	m := &LuckyBagContentInfo{}
	m.FixNilFields()
	return m
}
func (m *LuckyBagContentInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *LuckyBagLotteryInfo) Clone() *LuckyBagLotteryInfo {
	if m != nil {
		o := &LuckyBagLotteryInfo{}
		o.Id = m.Id
		o.EventId = m.EventId
		o.Rank = m.Rank
		o.Title = m.Title
		o.ShowType = m.ShowType
		o.ShowValue = m.ShowValue
		o.ShowSize = m.ShowSize
		o.AwardType1 = m.AwardType1
		o.AwardValue1 = m.AwardValue1
		o.AwardSize1 = m.AwardSize1
		o.AwardType2 = m.AwardType2
		o.AwardValue2 = m.AwardValue2
		o.AwardSize2 = m.AwardSize2
		o.AwardType3 = m.AwardType3
		o.AwardValue3 = m.AwardValue3
		o.AwardSize3 = m.AwardSize3
		return o
	}
	return nil
}

func InitLuckyBagLotteryInfo() *LuckyBagLotteryInfo {
	m := &LuckyBagLotteryInfo{}
	m.FixNilFields()
	return m
}
func (m *LuckyBagLotteryInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *LuckyBagInfos) Clone() *LuckyBagInfos {
	if m != nil {
		o := &LuckyBagInfos{}
		if len(m.Version) > 0 {
			o.Version = make(map[uint32]uint32, len(m.Version))
			for k, e := range m.Version {
				o.Version[k] = e
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*LuckyBagInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		if len(m.TypeInfos) > 0 {
			o.TypeInfos = make([]*LuckyBagTypeInfo, len(m.TypeInfos))
			for k, e := range m.TypeInfos {
				o.TypeInfos[k] = e.Clone()
			}
		}
		if len(m.LotteryInfos) > 0 {
			o.LotteryInfos = make([]*LuckyBagLotteryInfo, len(m.LotteryInfos))
			for k, e := range m.LotteryInfos {
				o.LotteryInfos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitLuckyBagInfos() *LuckyBagInfos {
	m := &LuckyBagInfos{}
	m.FixNilFields()
	return m
}
func (m *LuckyBagInfos) FixNilFields() {
	if m != nil {

		if m.Version == nil {
			m.Version = make(map[uint32]uint32)
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

		for _, itor := range m.TypeInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.LotteryInfos {
			itor.FixNilFields()
		}

	}
}
func (m *LuckyBag) Clone() *LuckyBag {
	if m != nil {
		o := &LuckyBag{}
		o.Status = m.Status
		o.Code = m.Code
		return o
	}
	return nil
}

func InitLuckyBag() *LuckyBag {
	m := &LuckyBag{}
	m.FixNilFields()
	return m
}
func (m *LuckyBag) FixNilFields() {
	if m != nil {

	}
}
func (m *LuckyBagLotteryRankValue) Clone() *LuckyBagLotteryRankValue {
	if m != nil {
		o := &LuckyBagLotteryRankValue{}
		o.Rank = m.Rank
		o.Code = m.Code
		o.User = m.User.Clone()
		return o
	}
	return nil
}

func InitLuckyBagLotteryRankValue() *LuckyBagLotteryRankValue {
	m := &LuckyBagLotteryRankValue{}
	m.FixNilFields()
	return m
}
func (m *LuckyBagLotteryRankValue) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *OperateAdvertiseInfo) Clone() *OperateAdvertiseInfo {
	if m != nil {
		o := &OperateAdvertiseInfo{}
		o.Id = m.Id
		o.Type = m.Type
		o.Level = m.Level
		o.Name = m.Name
		o.Icon = m.Icon
		o.ServerLimit = m.ServerLimit
		o.TimeType = m.TimeType
		o.ViewTime = m.ViewTime
		o.OpenTime = m.OpenTime
		o.EndTime = m.EndTime
		o.TitleFont = m.TitleFont
		o.Description = m.Description
		o.KnightBatType = m.KnightBatType
		o.KnightBase = m.KnightBase
		o.Intro = m.Intro
		if len(m.Shows) > 0 {
			o.Shows = make([]*OperateAdvertiseShow, len(m.Shows))
			for k, e := range m.Shows {
				o.Shows[k] = e.Clone()
			}
		}
		if len(m.FunctionBtns) > 0 {
			o.FunctionBtns = make([]*OperateAdvertiseFunctionBtn, len(m.FunctionBtns))
			for k, e := range m.FunctionBtns {
				o.FunctionBtns[k] = e.Clone()
			}
		}
		o.Rank = m.Rank
		o.ArtFont = m.ArtFont
		o.AwardName = m.AwardName
		o.AwardQuality = m.AwardQuality
		o.Entrance = m.Entrance
		o.KnightEffect = m.KnightEffect
		o.Effect = m.Effect
		return o
	}
	return nil
}

func InitOperateAdvertiseInfo() *OperateAdvertiseInfo {
	m := &OperateAdvertiseInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateAdvertiseInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Shows {
			itor.FixNilFields()
		}

		for _, itor := range m.FunctionBtns {
			itor.FixNilFields()
		}

	}
}
func (m *OperateAdvertiseShow) Clone() *OperateAdvertiseShow {
	if m != nil {
		o := &OperateAdvertiseShow{}
		o.Type = m.Type
		o.Value = m.Value
		return o
	}
	return nil
}

func InitOperateAdvertiseShow() *OperateAdvertiseShow {
	m := &OperateAdvertiseShow{}
	m.FixNilFields()
	return m
}
func (m *OperateAdvertiseShow) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateAdvertiseFunctionBtn) Clone() *OperateAdvertiseFunctionBtn {
	if m != nil {
		o := &OperateAdvertiseFunctionBtn{}
		o.Type = m.Type
		o.Value1 = m.Value1
		o.Value2 = m.Value2
		o.Txt = m.Txt
		o.Value3 = m.Value3
		return o
	}
	return nil
}

func InitOperateAdvertiseFunctionBtn() *OperateAdvertiseFunctionBtn {
	m := &OperateAdvertiseFunctionBtn{}
	m.FixNilFields()
	return m
}
func (m *OperateAdvertiseFunctionBtn) FixNilFields() {
	if m != nil {

	}
}
func (m *ActivityAdvertiseInfos) Clone() *ActivityAdvertiseInfos {
	if m != nil {
		o := &ActivityAdvertiseInfos{}
		if len(m.Version) > 0 {
			o.Version = make(map[uint32]uint32, len(m.Version))
			for k, e := range m.Version {
				o.Version[k] = e
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*OperateAdvertiseInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitActivityAdvertiseInfos() *ActivityAdvertiseInfos {
	m := &ActivityAdvertiseInfos{}
	m.FixNilFields()
	return m
}
func (m *ActivityAdvertiseInfos) FixNilFields() {
	if m != nil {

		if m.Version == nil {
			m.Version = make(map[uint32]uint32)
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

	}
}
func (m *OperateRankAwardInfo) Clone() *OperateRankAwardInfo {
	if m != nil {
		o := &OperateRankAwardInfo{}
		o.Id = m.Id
		o.RankId = m.RankId
		o.RankLow = m.RankLow
		o.RankHigh = m.RankHigh
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.MailId = m.MailId
		return o
	}
	return nil
}

func InitOperateRankAwardInfo() *OperateRankAwardInfo {
	m := &OperateRankAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateRankAwardInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *OperateRankInfo) Clone() *OperateRankInfo {
	if m != nil {
		o := &OperateRankInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.SubId = m.SubId
		o.NameEnter = m.NameEnter
		o.Name = m.Name
		o.Des = m.Des
		o.Title1 = m.Title1
		o.Title2 = m.Title2
		o.Title3 = m.Title3
		o.ResourceGroup = m.ResourceGroup
		o.FunctionId = m.FunctionId
		o.ShowNumber = m.ShowNumber
		o.RewardNum = m.RewardNum
		o.StorageNum = m.StorageNum
		return o
	}
	return nil
}

func InitOperateRankInfo() *OperateRankInfo {
	m := &OperateRankInfo{}
	m.FixNilFields()
	return m
}
func (m *OperateRankInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *OperateRankConfig) Clone() *OperateRankConfig {
	if m != nil {
		o := &OperateRankConfig{}
		if len(m.ServerVersion) > 0 {
			o.ServerVersion = make(map[uint32]uint32, len(m.ServerVersion))
			for k, e := range m.ServerVersion {
				o.ServerVersion[k] = e
			}
		}
		if len(m.AwardInfos) > 0 {
			o.AwardInfos = make([]*OperateRankAwardInfo, len(m.AwardInfos))
			for k, e := range m.AwardInfos {
				o.AwardInfos[k] = e.Clone()
			}
		}
		if len(m.RankInfos) > 0 {
			o.RankInfos = make([]*OperateRankInfo, len(m.RankInfos))
			for k, e := range m.RankInfos {
				o.RankInfos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitOperateRankConfig() *OperateRankConfig {
	m := &OperateRankConfig{}
	m.FixNilFields()
	return m
}
func (m *OperateRankConfig) FixNilFields() {
	if m != nil {

		if m.ServerVersion == nil {
			m.ServerVersion = make(map[uint32]uint32)
		}

		for _, itor := range m.AwardInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.RankInfos {
			itor.FixNilFields()
		}

	}
}
func (m *MiningActivityAccumulatedInfo) Clone() *MiningActivityAccumulatedInfo {
	if m != nil {
		o := &MiningActivityAccumulatedInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.AccumulatedType = m.AccumulatedType
		o.AccumulatedValue = m.AccumulatedValue
		o.AwardType1 = m.AwardType1
		o.AwardValue1 = m.AwardValue1
		o.AwardSize1 = m.AwardSize1
		o.AwardType2 = m.AwardType2
		o.AwardValue2 = m.AwardValue2
		o.AwardSize2 = m.AwardSize2
		return o
	}
	return nil
}

func InitMiningActivityAccumulatedInfo() *MiningActivityAccumulatedInfo {
	m := &MiningActivityAccumulatedInfo{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityAccumulatedInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *MiningActivityAwardInfo) Clone() *MiningActivityAwardInfo {
	if m != nil {
		o := &MiningActivityAwardInfo{}
		o.Id = m.Id
		o.Group = m.Group
		o.AwardType1 = m.AwardType1
		o.AwardValue1 = m.AwardValue1
		o.AwardSize1 = m.AwardSize1
		o.AwardType2 = m.AwardType2
		o.AwardValue2 = m.AwardValue2
		o.AwardSize2 = m.AwardSize2
		o.Weight = m.Weight
		return o
	}
	return nil
}

func InitMiningActivityAwardInfo() *MiningActivityAwardInfo {
	m := &MiningActivityAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityAwardInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *MiningActivityConfigInfo) Clone() *MiningActivityConfigInfo {
	if m != nil {
		o := &MiningActivityConfigInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.LevelMin = m.LevelMin
		o.LevelMax = m.LevelMax
		o.NormalMiningNum = m.NormalMiningNum
		o.SurpriseMiningNum = m.SurpriseMiningNum
		o.AverageAward = m.AverageAward
		o.BaseBigAward = m.BaseBigAward
		o.StageBigAward = m.StageBigAward
		o.SurpriseBigAward = m.SurpriseBigAward
		o.BigAwardProb = m.BigAwardProb
		o.CostType = m.CostType
		o.CostValue = m.CostValue
		o.CostSize = m.CostSize
		o.NormalMonsterShow = m.NormalMonsterShow
		o.SurpriseMonsterShow = m.SurpriseMonsterShow
		return o
	}
	return nil
}

func InitMiningActivityConfigInfo() *MiningActivityConfigInfo {
	m := &MiningActivityConfigInfo{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityConfigInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *MiningActivityGiftInfo) Clone() *MiningActivityGiftInfo {
	if m != nil {
		o := &MiningActivityGiftInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.Icon = m.Icon
		o.AwardType1 = m.AwardType1
		o.AwardValue1 = m.AwardValue1
		o.AwardSize1 = m.AwardSize1
		o.AwardType2 = m.AwardType2
		o.AwardValue2 = m.AwardValue2
		o.AwardSize2 = m.AwardSize2
		o.AwardType3 = m.AwardType3
		o.AwardValue3 = m.AwardValue3
		o.AwardSize3 = m.AwardSize3
		o.LimitType = m.LimitType
		o.LimitNum = m.LimitNum
		o.Type = m.Type
		o.CostType = m.CostType
		o.CostValue = m.CostValue
		o.CostSize = m.CostSize
		o.OriginalPrice = m.OriginalPrice
		o.Discount = m.Discount
		o.PrivilegeTag = m.PrivilegeTag
		o.Redpoint = m.Redpoint
		o.ProductId = m.ProductId
		o.Price = m.Price
		return o
	}
	return nil
}

func InitMiningActivityGiftInfo() *MiningActivityGiftInfo {
	m := &MiningActivityGiftInfo{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityGiftInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *MiningActivityGoodsInfo) Clone() *MiningActivityGoodsInfo {
	if m != nil {
		o := &MiningActivityGoodsInfo{}
		o.Id = m.Id
		o.GoodsGroup = m.GoodsGroup
		o.AwardType = m.AwardType
		o.AwardValue = m.AwardValue
		o.AwardSize = m.AwardSize
		o.LimitType = m.LimitType
		o.LimitNum = m.LimitNum
		o.CostType = m.CostType
		o.CostValue = m.CostValue
		o.CostSize = m.CostSize
		o.RedPoint = m.RedPoint
		o.Tag = m.Tag
		return o
	}
	return nil
}

func InitMiningActivityGoodsInfo() *MiningActivityGoodsInfo {
	m := &MiningActivityGoodsInfo{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityGoodsInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *MiningActivityProbInfo) Clone() *MiningActivityProbInfo {
	if m != nil {
		o := &MiningActivityProbInfo{}
		o.Id = m.Id
		o.Group = m.Group
		o.Number = m.Number
		o.Prob = m.Prob
		return o
	}
	return nil
}

func InitMiningActivityProbInfo() *MiningActivityProbInfo {
	m := &MiningActivityProbInfo{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityProbInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *MiningActivityShopInfo) Clone() *MiningActivityShopInfo {
	if m != nil {
		o := &MiningActivityShopInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.Level = m.Level
		o.UnlockConditionType = m.UnlockConditionType
		o.UnlockConditionValue_1 = m.UnlockConditionValue_1
		o.UnlockConditionValue_2 = m.UnlockConditionValue_2
		o.UnlockConditionValue_3 = m.UnlockConditionValue_3
		o.AwardType1 = m.AwardType1
		o.AwardValue1 = m.AwardValue1
		o.AwardSize1 = m.AwardSize1
		o.AwardType2 = m.AwardType2
		o.AwardValue2 = m.AwardValue2
		o.AwardSize2 = m.AwardSize2
		o.GoodsGroup = m.GoodsGroup
		return o
	}
	return nil
}

func InitMiningActivityShopInfo() *MiningActivityShopInfo {
	m := &MiningActivityShopInfo{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityShopInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *MiningActivityInfo) Clone() *MiningActivityInfo {
	if m != nil {
		o := &MiningActivityInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.IconEnter = m.IconEnter
		o.NameEnter = m.NameEnter
		o.SubactivityType = m.SubactivityType
		o.SubactivityValue = m.SubactivityValue
		o.Name = m.Name
		o.ActivityOpen = m.ActivityOpen
		o.ActivityClose = m.ActivityClose
		o.ShowType_1 = m.ShowType_1
		o.ShowValue_1 = m.ShowValue_1
		o.ShowType_2 = m.ShowType_2
		o.ShowValue_2 = m.ShowValue_2
		o.Bg = m.Bg
		o.Picture = m.Picture
		o.Title = m.Title
		o.Des = m.Des
		o.ThemePic = m.ThemePic
		o.ThemeTitle = m.ThemeTitle
		o.ThemeTxt = m.ThemeTxt
		o.ThemeExtraType = m.ThemeExtraType
		o.ThemeExtraValue = m.ThemeExtraValue
		o.Priority = m.Priority
		o.HelpTxt = m.HelpTxt
		o.TxtId = m.TxtId
		o.HelpId = m.HelpId
		return o
	}
	return nil
}

func InitMiningActivityInfo() *MiningActivityInfo {
	m := &MiningActivityInfo{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *MiningActivityTaskInfo) Clone() *MiningActivityTaskInfo {
	if m != nil {
		o := &MiningActivityTaskInfo{}
		o.Id = m.Id
		o.ActivityGroup = m.ActivityGroup
		o.Name = m.Name
		o.Event = m.Event
		o.Value = m.Value
		o.Progress = m.Progress
		o.AwardType1 = m.AwardType1
		o.AwardValue1 = m.AwardValue1
		o.AwardSize1 = m.AwardSize1
		o.AwardType2 = m.AwardType2
		o.AwardValue2 = m.AwardValue2
		o.AwardSize2 = m.AwardSize2
		o.AwardType3 = m.AwardType3
		o.AwardValue3 = m.AwardValue3
		o.AwardSize3 = m.AwardSize3
		o.Jump = m.Jump
		return o
	}
	return nil
}

func InitMiningActivityTaskInfo() *MiningActivityTaskInfo {
	m := &MiningActivityTaskInfo{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityTaskInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *MiningActivityConfig) Clone() *MiningActivityConfig {
	if m != nil {
		o := &MiningActivityConfig{}
		if len(m.ServerVersion) > 0 {
			o.ServerVersion = make(map[uint32]uint32, len(m.ServerVersion))
			for k, e := range m.ServerVersion {
				o.ServerVersion[k] = e
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*MiningActivityInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		if len(m.Configs) > 0 {
			o.Configs = make([]*MiningActivityConfigInfo, len(m.Configs))
			for k, e := range m.Configs {
				o.Configs[k] = e.Clone()
			}
		}
		if len(m.Accumulateds) > 0 {
			o.Accumulateds = make([]*MiningActivityAccumulatedInfo, len(m.Accumulateds))
			for k, e := range m.Accumulateds {
				o.Accumulateds[k] = e.Clone()
			}
		}
		if len(m.Goods) > 0 {
			o.Goods = make([]*MiningActivityGoodsInfo, len(m.Goods))
			for k, e := range m.Goods {
				o.Goods[k] = e.Clone()
			}
		}
		if len(m.Shops) > 0 {
			o.Shops = make([]*MiningActivityShopInfo, len(m.Shops))
			for k, e := range m.Shops {
				o.Shops[k] = e.Clone()
			}
		}
		if len(m.Gifts) > 0 {
			o.Gifts = make([]*MiningActivityGiftInfo, len(m.Gifts))
			for k, e := range m.Gifts {
				o.Gifts[k] = e.Clone()
			}
		}
		if len(m.Tasks) > 0 {
			o.Tasks = make([]*MiningActivityTaskInfo, len(m.Tasks))
			for k, e := range m.Tasks {
				o.Tasks[k] = e.Clone()
			}
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*MiningActivityAwardInfo, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.Probs) > 0 {
			o.Probs = make([]*MiningActivityProbInfo, len(m.Probs))
			for k, e := range m.Probs {
				o.Probs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitMiningActivityConfig() *MiningActivityConfig {
	m := &MiningActivityConfig{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityConfig) FixNilFields() {
	if m != nil {

		if m.ServerVersion == nil {
			m.ServerVersion = make(map[uint32]uint32)
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

		for _, itor := range m.Configs {
			itor.FixNilFields()
		}

		for _, itor := range m.Accumulateds {
			itor.FixNilFields()
		}

		for _, itor := range m.Goods {
			itor.FixNilFields()
		}

		for _, itor := range m.Shops {
			itor.FixNilFields()
		}

		for _, itor := range m.Gifts {
			itor.FixNilFields()
		}

		for _, itor := range m.Tasks {
			itor.FixNilFields()
		}

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		for _, itor := range m.Probs {
			itor.FixNilFields()
		}

	}
}
func (m *MiningActivityMining) Clone() *MiningActivityMining {
	if m != nil {
		o := &MiningActivityMining{}
		o.Level = m.Level
		o.IsBigGot = m.IsBigGot
		if len(m.Grids) > 0 {
			o.Grids = make([]*SmallKV, len(m.Grids))
			for k, e := range m.Grids {
				o.Grids[k] = e.Clone()
			}
		}
		o.TotalTimes = m.TotalTimes
		if len(m.TimesAwards) > 0 {
			o.TimesAwards = make([]uint32, len(m.TimesAwards))
			copy(o.TimesAwards, m.TimesAwards)
		}
		return o
	}
	return nil
}

func InitMiningActivityMining() *MiningActivityMining {
	m := &MiningActivityMining{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityMining) FixNilFields() {
	if m != nil {

		for _, itor := range m.Grids {
			itor.FixNilFields()
		}

	}
}
func (m *MiningActivityTask) Clone() *MiningActivityTask {
	if m != nil {
		o := &MiningActivityTask{}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.AwardIds) > 0 {
			o.AwardIds = make([]uint32, len(m.AwardIds))
			copy(o.AwardIds, m.AwardIds)
		}
		return o
	}
	return nil
}

func InitMiningActivityTask() *MiningActivityTask {
	m := &MiningActivityTask{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityTask) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *MiningActivityShop) Clone() *MiningActivityShop {
	if m != nil {
		o := &MiningActivityShop{}
		if len(m.LevelGoods) > 0 {
			o.LevelGoods = make(map[uint32]*GoodsList, len(m.LevelGoods))
			for k, e := range m.LevelGoods {
				o.LevelGoods[k] = e.Clone()
			}
		}
		if len(m.LevelBuyNums) > 0 {
			o.LevelBuyNums = make(map[uint32]uint32, len(m.LevelBuyNums))
			for k, e := range m.LevelBuyNums {
				o.LevelBuyNums[k] = e
			}
		}
		if len(m.UnlockResConditions) > 0 {
			o.UnlockResConditions = make([]*Resource, len(m.UnlockResConditions))
			for k, e := range m.UnlockResConditions {
				o.UnlockResConditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitMiningActivityShop() *MiningActivityShop {
	m := &MiningActivityShop{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityShop) FixNilFields() {
	if m != nil {

		if m.LevelGoods == nil {
			m.LevelGoods = make(map[uint32]*GoodsList)
		}
		for _, itor := range m.LevelGoods {
			itor.FixNilFields()
		}

		if m.LevelBuyNums == nil {
			m.LevelBuyNums = make(map[uint32]uint32)
		}

		for _, itor := range m.UnlockResConditions {
			itor.FixNilFields()
		}

	}
}
func (m *MiningActivityGift) Clone() *MiningActivityGift {
	if m != nil {
		o := &MiningActivityGift{}
		if len(m.BuyNums) > 0 {
			o.BuyNums = make(map[uint32]uint32, len(m.BuyNums))
			for k, e := range m.BuyNums {
				o.BuyNums[k] = e
			}
		}
		return o
	}
	return nil
}

func InitMiningActivityGift() *MiningActivityGift {
	m := &MiningActivityGift{}
	m.FixNilFields()
	return m
}
func (m *MiningActivityGift) FixNilFields() {
	if m != nil {

		if m.BuyNums == nil {
			m.BuyNums = make(map[uint32]uint32)
		}

	}
}
func (m *MiningActivity) Clone() *MiningActivity {
	if m != nil {
		o := &MiningActivity{}
		o.Group = m.Group
		o.ResetTime = m.ResetTime
		o.Mining = m.Mining.Clone()
		o.Task = m.Task.Clone()
		o.Shop = m.Shop.Clone()
		o.Gift = m.Gift.Clone()
		return o
	}
	return nil
}

func InitMiningActivity() *MiningActivity {
	m := &MiningActivity{}
	m.FixNilFields()
	return m
}
func (m *MiningActivity) FixNilFields() {
	if m != nil {

		if m.Mining == nil {
			m.Mining = &MiningActivityMining{}
		}
		m.Mining.FixNilFields()

		if m.Task == nil {
			m.Task = &MiningActivityTask{}
		}
		m.Task.FixNilFields()

		if m.Shop == nil {
			m.Shop = &MiningActivityShop{}
		}
		m.Shop.FixNilFields()

		if m.Gift == nil {
			m.Gift = &MiningActivityGift{}
		}
		m.Gift.FixNilFields()

	}
}
func (m *RacialArticle) Clone() *RacialArticle {
	if m != nil {
		o := &RacialArticle{}
		o.Id = m.Id
		if len(m.Chapters) > 0 {
			o.Chapters = make([]*RacialChapter, len(m.Chapters))
			for k, e := range m.Chapters {
				o.Chapters[k] = e.Clone()
			}
		}
		o.Level = m.Level
		o.Score = m.Score
		return o
	}
	return nil
}

func InitRacialArticle() *RacialArticle {
	m := &RacialArticle{}
	m.FixNilFields()
	return m
}
func (m *RacialArticle) FixNilFields() {
	if m != nil {

		for _, itor := range m.Chapters {
			itor.FixNilFields()
		}

	}
}
func (m *RacialChapter) Clone() *RacialChapter {
	if m != nil {
		o := &RacialChapter{}
		if len(m.Groups) > 0 {
			o.Groups = make([]*SmallKV, len(m.Groups))
			for k, e := range m.Groups {
				o.Groups[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitRacialChapter() *RacialChapter {
	m := &RacialChapter{}
	m.FixNilFields()
	return m
}
func (m *RacialChapter) FixNilFields() {
	if m != nil {

		for _, itor := range m.Groups {
			itor.FixNilFields()
		}

	}
}
func (m *SwordForgingGroup) Clone() *SwordForgingGroup {
	if m != nil {
		o := &SwordForgingGroup{}
		o.Group = m.Group
		o.Finished = m.Finished
		if len(m.AwardTaskSteps) > 0 {
			o.AwardTaskSteps = make(map[uint32]uint32, len(m.AwardTaskSteps))
			for k, e := range m.AwardTaskSteps {
				o.AwardTaskSteps[k] = e
			}
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitSwordForgingGroup() *SwordForgingGroup {
	m := &SwordForgingGroup{}
	m.FixNilFields()
	return m
}
func (m *SwordForgingGroup) FixNilFields() {
	if m != nil {

		if m.AwardTaskSteps == nil {
			m.AwardTaskSteps = make(map[uint32]uint32)
		}

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *SwordForgingBase) Clone() *SwordForgingBase {
	if m != nil {
		o := &SwordForgingBase{}
		if len(m.Groups) > 0 {
			o.Groups = make([]*SwordForgingGroup, len(m.Groups))
			for k, e := range m.Groups {
				o.Groups[k] = e.Clone()
			}
		}
		o.InheritId = m.InheritId
		o.ChangeInheritTimes = m.ChangeInheritTimes
		o.Stage = m.Stage
		o.PreviewInheritId = m.PreviewInheritId
		if len(m.GroupLevels) > 0 {
			o.GroupLevels = make(map[uint32]uint32, len(m.GroupLevels))
			for k, e := range m.GroupLevels {
				o.GroupLevels[k] = e
			}
		}
		o.ActivedEarlierId = m.ActivedEarlierId
		return o
	}
	return nil
}

func InitSwordForgingBase() *SwordForgingBase {
	m := &SwordForgingBase{}
	m.FixNilFields()
	return m
}
func (m *SwordForgingBase) FixNilFields() {
	if m != nil {

		for _, itor := range m.Groups {
			itor.FixNilFields()
		}

		if m.GroupLevels == nil {
			m.GroupLevels = make(map[uint32]uint32)
		}

	}
}
func (m *CampTowerData) Clone() *CampTowerData {
	if m != nil {
		o := &CampTowerData{}
		o.Camp = m.Camp
		o.Stage = m.Stage
		o.Level = m.Level
		o.Reward = m.Reward.Clone()
		o.BreakStage = m.BreakStage
		return o
	}
	return nil
}

func InitCampTowerData() *CampTowerData {
	m := &CampTowerData{}
	m.FixNilFields()
	return m
}
func (m *CampTowerData) FixNilFields() {
	if m != nil {

		if m.Reward == nil {
			m.Reward = &Uint32S{}
		}
		m.Reward.FixNilFields()

	}
}
func (m *CampTower) Clone() *CampTower {
	if m != nil {
		o := &CampTower{}
		if len(m.CampTowerDatas) > 0 {
			o.CampTowerDatas = make([]*CampTowerData, len(m.CampTowerDatas))
			for k, e := range m.CampTowerDatas {
				o.CampTowerDatas[k] = e.Clone()
			}
		}
		o.CommonReward = m.CommonReward.Clone()
		return o
	}
	return nil
}

func InitCampTower() *CampTower {
	m := &CampTower{}
	m.FixNilFields()
	return m
}
func (m *CampTower) FixNilFields() {
	if m != nil {

		for _, itor := range m.CampTowerDatas {
			itor.FixNilFields()
		}

		if m.CommonReward == nil {
			m.CommonReward = &Uint32S{}
		}
		m.CommonReward.FixNilFields()

	}
}
func (m *Planet) Clone() *Planet {
	if m != nil {
		o := &Planet{}
		o.Sid = m.Sid
		o.Name = m.Name
		if len(m.Powers) > 0 {
			o.Powers = make([]*RankValue, len(m.Powers))
			for k, e := range m.Powers {
				o.Powers[k] = e.Clone()
			}
		}
		if len(m.Levels) > 0 {
			o.Levels = make([]*RankValue, len(m.Levels))
			for k, e := range m.Levels {
				o.Levels[k] = e.Clone()
			}
		}
		if len(m.MergedServerIds) > 0 {
			o.MergedServerIds = make([]uint64, len(m.MergedServerIds))
			copy(o.MergedServerIds, m.MergedServerIds)
		}
		return o
	}
	return nil
}

func InitPlanet() *Planet {
	m := &Planet{}
	m.FixNilFields()
	return m
}
func (m *Planet) FixNilFields() {
	if m != nil {

		for _, itor := range m.Powers {
			itor.FixNilFields()
		}

		for _, itor := range m.Levels {
			itor.FixNilFields()
		}

	}
}
func (m *MarkGuide) Clone() *MarkGuide {
	if m != nil {
		o := &MarkGuide{}
		o.Guides = m.Guides.Clone()
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitMarkGuide() *MarkGuide {
	m := &MarkGuide{}
	m.FixNilFields()
	return m
}
func (m *MarkGuide) FixNilFields() {
	if m != nil {

		if m.Guides == nil {
			m.Guides = &Uint32S{}
		}
		m.Guides.FixNilFields()

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *KnightFrag) Clone() *KnightFrag {
	if m != nil {
		o := &KnightFrag{}
		o.ResetTime = m.ResetTime
		if len(m.Knights) > 0 {
			o.Knights = make(map[uint32]uint32, len(m.Knights))
			for k, e := range m.Knights {
				o.Knights[k] = e
			}
		}
		return o
	}
	return nil
}

func InitKnightFrag() *KnightFrag {
	m := &KnightFrag{}
	m.FixNilFields()
	return m
}
func (m *KnightFrag) FixNilFields() {
	if m != nil {

		if m.Knights == nil {
			m.Knights = make(map[uint32]uint32)
		}

	}
}
func (m *EarthBossLogList) Clone() *EarthBossLogList {
	if m != nil {
		o := &EarthBossLogList{}
		if len(m.Logs) > 0 {
			o.Logs = make([]*EarthBossLog, len(m.Logs))
			for k, e := range m.Logs {
				o.Logs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitEarthBossLogList() *EarthBossLogList {
	m := &EarthBossLogList{}
	m.FixNilFields()
	return m
}
func (m *EarthBossLogList) FixNilFields() {
	if m != nil {

		for _, itor := range m.Logs {
			itor.FixNilFields()
		}

	}
}
func (m *EarthBossLog) Clone() *EarthBossLog {
	if m != nil {
		o := &EarthBossLog{}
		o.BossLevel = m.BossLevel
		o.IsSummary = m.IsSummary
		o.Timestamp = m.Timestamp
		o.LogType = m.LogType
		o.KillCount = m.KillCount
		o.UserCount = m.UserCount
		o.LeagueName = m.LeagueName
		o.LeagueId = m.LeagueId
		o.LeagueBadge = m.LeagueBadge
		o.Harm = m.Harm
		o.UserId = m.UserId
		o.UserName = m.UserName
		o.UserStarId = m.UserStarId
		o.UserBaseId = m.UserBaseId
		if len(m.UserAppearances) > 0 {
			o.UserAppearances = make([]uint32, len(m.UserAppearances))
			copy(o.UserAppearances, m.UserAppearances)
		}
		o.SwordForgingInheritId = m.SwordForgingInheritId
		if len(m.LuckyAwards) > 0 {
			o.LuckyAwards = make([]*Resource, len(m.LuckyAwards))
			for k, e := range m.LuckyAwards {
				o.LuckyAwards[k] = e.Clone()
			}
		}
		o.ServerId = m.ServerId
		o.HarmPercent = m.HarmPercent
		o.IsWin = m.IsWin
		return o
	}
	return nil
}

func InitEarthBossLog() *EarthBossLog {
	m := &EarthBossLog{}
	m.FixNilFields()
	return m
}
func (m *EarthBossLog) FixNilFields() {
	if m != nil {

		for _, itor := range m.LuckyAwards {
			itor.FixNilFields()
		}

	}
}
func (m *EarthBossShowUser) Clone() *EarthBossShowUser {
	if m != nil {
		o := &EarthBossShowUser{}
		o.User = m.User.Clone()
		o.ShowType = m.ShowType
		o.Value = m.Value
		o.Motto = m.Motto
		return o
	}
	return nil
}

func InitEarthBossShowUser() *EarthBossShowUser {
	m := &EarthBossShowUser{}
	m.FixNilFields()
	return m
}
func (m *EarthBossShowUser) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *EarthBoss) Clone() *EarthBoss {
	if m != nil {
		o := &EarthBoss{}
		o.BossId = m.BossId
		o.Level = m.Level
		o.CurHp = m.CurHp
		o.MaxHp = m.MaxHp
		o.RebirthTime = m.RebirthTime
		o.MaxKilledLevel = m.MaxKilledLevel
		o.MaxHarmUser = m.MaxHarmUser.Clone()
		if len(m.HarmLogs) > 0 {
			o.HarmLogs = make([]*EarthBossHarmLog, len(m.HarmLogs))
			for k, e := range m.HarmLogs {
				o.HarmLogs[k] = e.Clone()
			}
		}
		if len(m.KillerNames) > 0 {
			o.KillerNames = make(map[uint32]string, len(m.KillerNames))
			for k, e := range m.KillerNames {
				o.KillerNames[k] = e
			}
		}
		o.UsersNum = m.UsersNum
		o.NextUsersNum = m.NextUsersNum
		o.MyMaxHarm = m.MyMaxHarm
		o.GetOpenAward = m.GetOpenAward
		return o
	}
	return nil
}

func InitEarthBoss() *EarthBoss {
	m := &EarthBoss{}
	m.FixNilFields()
	return m
}
func (m *EarthBoss) FixNilFields() {
	if m != nil {

		if m.MaxHarmUser == nil {
			m.MaxHarmUser = &EarthBossShowUser{}
		}
		m.MaxHarmUser.FixNilFields()

		for _, itor := range m.HarmLogs {
			itor.FixNilFields()
		}

		if m.KillerNames == nil {
			m.KillerNames = make(map[uint32]string)
		}

	}
}
func (m *EarthBossUser) Clone() *EarthBossUser {
	if m != nil {
		o := &EarthBossUser{}
		o.UserId = m.UserId
		o.TotalHarm = m.TotalHarm
		o.KillTimes = m.KillTimes
		o.SingleHarmMax = m.SingleHarmMax
		o.SingleHarmMaxTime = m.SingleHarmMaxTime
		if len(m.AwardIds) > 0 {
			o.AwardIds = make([]uint32, len(m.AwardIds))
			copy(o.AwardIds, m.AwardIds)
		}
		o.ChallengedNum = m.ChallengedNum
		o.Target = m.Target
		o.NextTarget = m.NextTarget
		o.HarmPercent = m.HarmPercent
		o.TotalFightTimes = m.TotalFightTimes
		return o
	}
	return nil
}

func InitEarthBossUser() *EarthBossUser {
	m := &EarthBossUser{}
	m.FixNilFields()
	return m
}
func (m *EarthBossUser) FixNilFields() {
	if m != nil {

	}
}
func (m *EarthBossHarmLog) Clone() *EarthBossHarmLog {
	if m != nil {
		o := &EarthBossHarmLog{}
		o.UserId = m.UserId
		o.UserName = m.UserName
		o.Harm = m.Harm
		return o
	}
	return nil
}

func InitEarthBossHarmLog() *EarthBossHarmLog {
	m := &EarthBossHarmLog{}
	m.FixNilFields()
	return m
}
func (m *EarthBossHarmLog) FixNilFields() {
	if m != nil {

	}
}
func (m *EarthBossMatchedPlayer) Clone() *EarthBossMatchedPlayer {
	if m != nil {
		o := &EarthBossMatchedPlayer{}
		o.Snap = m.Snap.Clone()
		o.Rank = m.Rank
		o.HarmPercent = m.HarmPercent
		return o
	}
	return nil
}

func InitEarthBossMatchedPlayer() *EarthBossMatchedPlayer {
	m := &EarthBossMatchedPlayer{}
	m.FixNilFields()
	return m
}
func (m *EarthBossMatchedPlayer) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *LeagueSacrificeLog) Clone() *LeagueSacrificeLog {
	if m != nil {
		o := &LeagueSacrificeLog{}
		o.Time = m.Time
		o.Type = m.Type
		o.ShipSkillType = m.ShipSkillType
		o.ShipSkillLevel = m.ShipSkillLevel
		o.PlunderLeagueName = m.PlunderLeagueName
		o.PlunderUserName = m.PlunderUserName
		o.HelperUserName = m.HelperUserName
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.ShipExp = m.ShipExp
		return o
	}
	return nil
}

func InitLeagueSacrificeLog() *LeagueSacrificeLog {
	m := &LeagueSacrificeLog{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificeLog) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *LeagueSacrificePlunderBrief) Clone() *LeagueSacrificePlunderBrief {
	if m != nil {
		o := &LeagueSacrificePlunderBrief{}
		o.Uuid = m.Uuid
		o.Time = m.Time
		o.PlunderUser = m.PlunderUser
		o.BePlunderedUser = m.BePlunderedUser
		o.PlunderInfoId = m.PlunderInfoId
		o.SelfHitBackState = m.SelfHitBackState
		o.HelperHitBackState = m.HelperHitBackState
		o.HelperName = m.HelperName
		o.HelperUser = m.HelperUser
		o.HitBackAwarded = m.HitBackAwarded
		return o
	}
	return nil
}

func InitLeagueSacrificePlunderBrief() *LeagueSacrificePlunderBrief {
	m := &LeagueSacrificePlunderBrief{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificePlunderBrief) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueSacrificePlundOtherBrief) Clone() *LeagueSacrificePlundOtherBrief {
	if m != nil {
		o := &LeagueSacrificePlundOtherBrief{}
		o.Uuid = m.Uuid
		o.Time = m.Time
		o.BePlundLeagueId = m.BePlundLeagueId
		o.BePlundLeagueName = m.BePlundLeagueName
		o.BePlundUserId = m.BePlundUserId
		o.BePlundUserName = m.BePlundUserName
		o.BePlundLeaguePos = m.BePlundLeaguePos
		o.Win = m.Win
		o.IsMonster = m.IsMonster
		return o
	}
	return nil
}

func InitLeagueSacrificePlundOtherBrief() *LeagueSacrificePlundOtherBrief {
	m := &LeagueSacrificePlundOtherBrief{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificePlundOtherBrief) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueSacrificeDailyPlundStat) Clone() *LeagueSacrificeDailyPlundStat {
	if m != nil {
		o := &LeagueSacrificeDailyPlundStat{}
		o.UserId = m.UserId
		o.ShipExp = m.ShipExp
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.PlundOthers) > 0 {
			o.PlundOthers = make([]*LeagueSacrificePlundOtherBrief, len(m.PlundOthers))
			for k, e := range m.PlundOthers {
				o.PlundOthers[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitLeagueSacrificeDailyPlundStat() *LeagueSacrificeDailyPlundStat {
	m := &LeagueSacrificeDailyPlundStat{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificeDailyPlundStat) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		for _, itor := range m.PlundOthers {
			itor.FixNilFields()
		}

	}
}
func (m *LeagueSacrificePlunder) Clone() *LeagueSacrificePlunder {
	if m != nil {
		o := &LeagueSacrificePlunder{}
		o.Brief = m.Brief.Clone()
		o.BePlunderedName = m.BePlunderedName
		return o
	}
	return nil
}

func InitLeagueSacrificePlunder() *LeagueSacrificePlunder {
	m := &LeagueSacrificePlunder{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificePlunder) FixNilFields() {
	if m != nil {

		if m.Brief == nil {
			m.Brief = &LeagueSacrificePlunderBrief{}
		}
		m.Brief.FixNilFields()

	}
}
func (m *LeagueSacrificeUser) Clone() *LeagueSacrificeUser {
	if m != nil {
		o := &LeagueSacrificeUser{}
		o.UserId = m.UserId
		if len(m.ShipSkillLevels) > 0 {
			o.ShipSkillLevels = make([]*SmallKV, len(m.ShipSkillLevels))
			for k, e := range m.ShipSkillLevels {
				o.ShipSkillLevels[k] = e.Clone()
			}
		}
		o.TransportId = m.TransportId
		o.TransportStartTime = m.TransportStartTime
		o.TransportFinishTime = m.TransportFinishTime
		o.BePlunderedNum = m.BePlunderedNum
		return o
	}
	return nil
}

func InitLeagueSacrificeUser() *LeagueSacrificeUser {
	m := &LeagueSacrificeUser{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificeUser) FixNilFields() {
	if m != nil {

		for _, itor := range m.ShipSkillLevels {
			itor.FixNilFields()
		}

	}
}
func (m *LeagueSacrificeUserSnap) Clone() *LeagueSacrificeUserSnap {
	if m != nil {
		o := &LeagueSacrificeUserSnap{}
		o.User = m.User.Clone()
		o.Snap = m.Snap.Clone()
		o.MonsterTeamId = m.MonsterTeamId
		o.MonsterTransportId = m.MonsterTransportId
		return o
	}
	return nil
}

func InitLeagueSacrificeUserSnap() *LeagueSacrificeUserSnap {
	m := &LeagueSacrificeUserSnap{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificeUserSnap) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &LeagueSacrificeUser{}
		}
		m.User.FixNilFields()

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *LeagueSacrificeDailyTask) Clone() *LeagueSacrificeDailyTask {
	if m != nil {
		o := &LeagueSacrificeDailyTask{}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.AwardTaskIds) > 0 {
			o.AwardTaskIds = make([]uint32, len(m.AwardTaskIds))
			copy(o.AwardTaskIds, m.AwardTaskIds)
		}
		return o
	}
	return nil
}

func InitLeagueSacrificeDailyTask() *LeagueSacrificeDailyTask {
	m := &LeagueSacrificeDailyTask{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificeDailyTask) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *LeagueSacrificeMyBase) Clone() *LeagueSacrificeMyBase {
	if m != nil {
		o := &LeagueSacrificeMyBase{}
		o.LeftSacrificedNum = m.LeftSacrificedNum
		o.PlunderedOtherNum = m.PlunderedOtherNum
		o.HelpedOtherNum = m.HelpedOtherNum
		o.MyData = m.MyData.Clone()
		o.MyTask = m.MyTask.Clone()
		o.Motto = m.Motto
		o.AssistantNum = m.AssistantNum
		return o
	}
	return nil
}

func InitLeagueSacrificeMyBase() *LeagueSacrificeMyBase {
	m := &LeagueSacrificeMyBase{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificeMyBase) FixNilFields() {
	if m != nil {

		if m.MyData == nil {
			m.MyData = &LeagueSacrificeUser{}
		}
		m.MyData.FixNilFields()

		if m.MyTask == nil {
			m.MyTask = &LeagueSacrificeDailyTask{}
		}
		m.MyTask.FixNilFields()

	}
}
func (m *LeagueSacrificeUserMotto) Clone() *LeagueSacrificeUserMotto {
	if m != nil {
		o := &LeagueSacrificeUserMotto{}
		o.UserId = m.UserId
		o.UserName = m.UserName
		o.Motto = m.Motto
		o.TransportId = m.TransportId
		return o
	}
	return nil
}

func InitLeagueSacrificeUserMotto() *LeagueSacrificeUserMotto {
	m := &LeagueSacrificeUserMotto{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificeUserMotto) FixNilFields() {
	if m != nil {

	}
}
func (m *CanPlunderLeagueBrief) Clone() *CanPlunderLeagueBrief {
	if m != nil {
		o := &CanPlunderLeagueBrief{}
		o.Snap = m.Snap.Clone()
		if len(m.UsersNum) > 0 {
			o.UsersNum = make(map[uint32]uint32, len(m.UsersNum))
			for k, e := range m.UsersNum {
				o.UsersNum[k] = e
			}
		}
		o.PlundExpTotal = m.PlundExpTotal
		return o
	}
	return nil
}

func InitCanPlunderLeagueBrief() *CanPlunderLeagueBrief {
	m := &CanPlunderLeagueBrief{}
	m.FixNilFields()
	return m
}
func (m *CanPlunderLeagueBrief) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &LeagueSnapshot{}
		}
		m.Snap.FixNilFields()

		if m.UsersNum == nil {
			m.UsersNum = make(map[uint32]uint32)
		}

	}
}
func (m *LeagueSacrificeBulletScreen) Clone() *LeagueSacrificeBulletScreen {
	if m != nil {
		o := &LeagueSacrificeBulletScreen{}
		o.Time = m.Time
		o.Type = m.Type
		o.Int1 = m.Int1
		o.Int2 = m.Int2
		o.Int3 = m.Int3
		o.Str1 = m.Str1
		o.Str2 = m.Str2
		o.Str3 = m.Str3
		return o
	}
	return nil
}

func InitLeagueSacrificeBulletScreen() *LeagueSacrificeBulletScreen {
	m := &LeagueSacrificeBulletScreen{}
	m.FixNilFields()
	return m
}
func (m *LeagueSacrificeBulletScreen) FixNilFields() {
	if m != nil {

	}
}
func (m *RoomInfo) Clone() *RoomInfo {
	if m != nil {
		o := &RoomInfo{}
		o.Id = m.Id
		o.SelectNum = m.SelectNum
		o.TopLeagueAveragePower = m.TopLeagueAveragePower
		o.LastWinnerLeague = m.LastWinnerLeague.Clone()
		return o
	}
	return nil
}

func InitRoomInfo() *RoomInfo {
	m := &RoomInfo{}
	m.FixNilFields()
	return m
}
func (m *RoomInfo) FixNilFields() {
	if m != nil {

		if m.LastWinnerLeague == nil {
			m.LastWinnerLeague = &LeagueWinner{}
		}
		m.LastWinnerLeague.FixNilFields()

	}
}
func (m *ChapterOccupier) Clone() *ChapterOccupier {
	if m != nil {
		o := &ChapterOccupier{}
		o.Id = m.Id
		o.LeagueId = m.LeagueId
		o.LeagueSid = m.LeagueSid
		o.LeagueName = m.LeagueName
		o.LeagueRatio = m.LeagueRatio
		o.TotalUsers = m.TotalUsers
		return o
	}
	return nil
}

func InitChapterOccupier() *ChapterOccupier {
	m := &ChapterOccupier{}
	m.FixNilFields()
	return m
}
func (m *ChapterOccupier) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueCombatUserInfo) Clone() *LeagueCombatUserInfo {
	if m != nil {
		o := &LeagueCombatUserInfo{}
		o.TotalScore = m.TotalScore
		o.BoostCount = m.BoostCount
		o.DefeatCount = m.DefeatCount
		if len(m.Buffs) > 0 {
			o.Buffs = make(map[uint32]int64, len(m.Buffs))
			for k, e := range m.Buffs {
				o.Buffs[k] = e
			}
		}
		o.RoomId = m.RoomId
		o.LastAttackTime = m.LastAttackTime
		o.LocalRank = m.LocalRank
		o.CrossRank = m.CrossRank
		o.LeagueRank = m.LeagueRank
		if len(m.AwardedIds) > 0 {
			o.AwardedIds = make([]uint32, len(m.AwardedIds))
			copy(o.AwardedIds, m.AwardedIds)
		}
		o.ShipSkillTime = m.ShipSkillTime
		o.ServerNum = m.ServerNum
		o.MassId = m.MassId
		o.ScoreRoom = m.ScoreRoom
		o.LastStageLoseTime = m.LastStageLoseTime
		return o
	}
	return nil
}

func InitLeagueCombatUserInfo() *LeagueCombatUserInfo {
	m := &LeagueCombatUserInfo{}
	m.FixNilFields()
	return m
}
func (m *LeagueCombatUserInfo) FixNilFields() {
	if m != nil {

		if m.Buffs == nil {
			m.Buffs = make(map[uint32]int64)
		}

	}
}
func (m *BoostInfo) Clone() *BoostInfo {
	if m != nil {
		o := &BoostInfo{}
		o.Uid = m.Uid
		o.Name = m.Name
		o.Count = m.Count
		return o
	}
	return nil
}

func InitBoostInfo() *BoostInfo {
	m := &BoostInfo{}
	m.FixNilFields()
	return m
}
func (m *BoostInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *StageOccupier) Clone() *StageOccupier {
	if m != nil {
		o := &StageOccupier{}
		o.Id = m.Id
		o.StartTime = m.StartTime
		o.Occupier = m.Occupier.Clone()
		o.StageLoseTime = m.StageLoseTime
		return o
	}
	return nil
}

func InitStageOccupier() *StageOccupier {
	m := &StageOccupier{}
	m.FixNilFields()
	return m
}
func (m *StageOccupier) FixNilFields() {
	if m != nil {

		if m.Occupier == nil {
			m.Occupier = &UserSnapshot{}
		}
		m.Occupier.FixNilFields()

	}
}
func (m *MiniRanklist) Clone() *MiniRanklist {
	if m != nil {
		o := &MiniRanklist{}
		o.Kind = m.Kind
		o.Type = m.Type
		o.Ranking = m.Ranking
		o.Value = m.Value
		if len(m.Users) > 0 {
			o.Users = make([]*RankValue, len(m.Users))
			for k, e := range m.Users {
				o.Users[k] = e.Clone()
			}
		}
		if len(m.Leagues) > 0 {
			o.Leagues = make([]*LeagueRankValue, len(m.Leagues))
			for k, e := range m.Leagues {
				o.Leagues[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitMiniRanklist() *MiniRanklist {
	m := &MiniRanklist{}
	m.FixNilFields()
	return m
}
func (m *MiniRanklist) FixNilFields() {
	if m != nil {

		for _, itor := range m.Users {
			itor.FixNilFields()
		}

		for _, itor := range m.Leagues {
			itor.FixNilFields()
		}

	}
}
func (m *UserWinner) Clone() *UserWinner {
	if m != nil {
		o := &UserWinner{}
		o.ServerId = m.ServerId
		o.UserId = m.UserId
		o.FinalRank = m.FinalRank
		o.TotalScore = m.TotalScore
		o.Snap = m.Snap.Clone()
		return o
	}
	return nil
}

func InitUserWinner() *UserWinner {
	m := &UserWinner{}
	m.FixNilFields()
	return m
}
func (m *UserWinner) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *LeagueWinner) Clone() *LeagueWinner {
	if m != nil {
		o := &LeagueWinner{}
		o.ServerId = m.ServerId
		o.LeagueId = m.LeagueId
		o.LeagueName = m.LeagueName
		o.LeagueLevel = m.LeagueLevel
		o.LeagueShipLevel = m.LeagueShipLevel
		o.FinalRank = m.FinalRank
		o.TotalScore = m.TotalScore
		o.LeagueBadge = m.LeagueBadge
		return o
	}
	return nil
}

func InitLeagueWinner() *LeagueWinner {
	m := &LeagueWinner{}
	m.FixNilFields()
	return m
}
func (m *LeagueWinner) FixNilFields() {
	if m != nil {

	}
}
func (m *StageOccupierChange) Clone() *StageOccupierChange {
	if m != nil {
		o := &StageOccupierChange{}
		o.Type = m.Type
		o.Occupier = m.Occupier.Clone()
		o.Defeater = m.Defeater.Clone()
		o.Loser = m.Loser.Clone()
		return o
	}
	return nil
}

func InitStageOccupierChange() *StageOccupierChange {
	m := &StageOccupierChange{}
	m.FixNilFields()
	return m
}
func (m *StageOccupierChange) FixNilFields() {
	if m != nil {

		if m.Occupier == nil {
			m.Occupier = &StageOccupier{}
		}
		m.Occupier.FixNilFields()

		if m.Defeater == nil {
			m.Defeater = &StageOccupier{}
		}
		m.Defeater.FixNilFields()

		if m.Loser == nil {
			m.Loser = &LeagueCombatUserInfo{}
		}
		m.Loser.FixNilFields()

	}
}
func (m *ChapterOccupierChange) Clone() *ChapterOccupierChange {
	if m != nil {
		o := &ChapterOccupierChange{}
		o.LeagueId = m.LeagueId
		o.LeagueSid = m.LeagueSid
		o.LeagueName = m.LeagueName
		o.StartTime = m.StartTime
		o.FinishTime = m.FinishTime
		o.LeagueRatio = m.LeagueRatio
		o.Cancel = m.Cancel
		o.TotalUsers = m.TotalUsers
		return o
	}
	return nil
}

func InitChapterOccupierChange() *ChapterOccupierChange {
	m := &ChapterOccupierChange{}
	m.FixNilFields()
	return m
}
func (m *ChapterOccupierChange) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueLuckyBagUser) Clone() *LeagueLuckyBagUser {
	if m != nil {
		o := &LeagueLuckyBagUser{}
		o.Id = m.Id
		o.TodayGrabbedTimes = m.TodayGrabbedTimes
		o.TodayGrabbedNum = m.TodayGrabbedNum
		o.RefreshTime = m.RefreshTime
		return o
	}
	return nil
}

func InitLeagueLuckyBagUser() *LeagueLuckyBagUser {
	m := &LeagueLuckyBagUser{}
	m.FixNilFields()
	return m
}
func (m *LeagueLuckyBagUser) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueLuckyBagGrabbedUser) Clone() *LeagueLuckyBagGrabbedUser {
	if m != nil {
		o := &LeagueLuckyBagGrabbedUser{}
		o.Uid = m.Uid
		o.Gold = m.Gold
		return o
	}
	return nil
}

func InitLeagueLuckyBagGrabbedUser() *LeagueLuckyBagGrabbedUser {
	m := &LeagueLuckyBagGrabbedUser{}
	m.FixNilFields()
	return m
}
func (m *LeagueLuckyBagGrabbedUser) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueLuckyBag) Clone() *LeagueLuckyBag {
	if m != nil {
		o := &LeagueLuckyBag{}
		o.BaseId = m.BaseId
		o.Id = m.Id
		o.Uid = m.Uid
		o.Lid = m.Lid
		o.Name = m.Name
		o.CreateTime = m.CreateTime
		o.SendTime = m.SendTime
		o.GrabbedCnt = m.GrabbedCnt
		o.GrabbedNum = m.GrabbedNum
		if len(m.Users) > 0 {
			o.Users = make([]*LeagueLuckyBagGrabbedUser, len(m.Users))
			for k, e := range m.Users {
				o.Users[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitLeagueLuckyBag() *LeagueLuckyBag {
	m := &LeagueLuckyBag{}
	m.FixNilFields()
	return m
}
func (m *LeagueLuckyBag) FixNilFields() {
	if m != nil {

		for _, itor := range m.Users {
			itor.FixNilFields()
		}

	}
}
func (m *LeagueLuckyBags) Clone() *LeagueLuckyBags {
	if m != nil {
		o := &LeagueLuckyBags{}
		if len(m.Bags) > 0 {
			o.Bags = make([]*LeagueLuckyBag, len(m.Bags))
			for k, e := range m.Bags {
				o.Bags[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitLeagueLuckyBags() *LeagueLuckyBags {
	m := &LeagueLuckyBags{}
	m.FixNilFields()
	return m
}
func (m *LeagueLuckyBags) FixNilFields() {
	if m != nil {

		for _, itor := range m.Bags {
			itor.FixNilFields()
		}

	}
}
func (m *KnightDegree) Clone() *KnightDegree {
	if m != nil {
		o := &KnightDegree{}
		o.Stage = m.Stage
		if len(m.FillResNums) > 0 {
			o.FillResNums = make([]uint32, len(m.FillResNums))
			copy(o.FillResNums, m.FillResNums)
		}
		if len(m.SelectedSkills) > 0 {
			o.SelectedSkills = make(map[uint32]uint32, len(m.SelectedSkills))
			for k, e := range m.SelectedSkills {
				o.SelectedSkills[k] = e
			}
		}
		return o
	}
	return nil
}

func InitKnightDegree() *KnightDegree {
	m := &KnightDegree{}
	m.FixNilFields()
	return m
}
func (m *KnightDegree) FixNilFields() {
	if m != nil {

		if m.SelectedSkills == nil {
			m.SelectedSkills = make(map[uint32]uint32)
		}

	}
}
func (m *Strength) Clone() *Strength {
	if m != nil {
		o := &Strength{}
		o.Num = m.Num
		o.RecoverTime = m.RecoverTime
		o.Value = m.Value
		return o
	}
	return nil
}

func InitStrength() *Strength {
	m := &Strength{}
	m.FixNilFields()
	return m
}
func (m *Strength) FixNilFields() {
	if m != nil {

	}
}
func (m *CardPoolInfo) Clone() *CardPoolInfo {
	if m != nil {
		o := &CardPoolInfo{}
		o.Id = m.Id
		o.FreeTimes = m.FreeTimes
		o.DrawTimes = m.DrawTimes
		o.GuaranteeTimes = m.GuaranteeTimes
		o.GiftGroup = m.GiftGroup
		if len(m.ReceivedGifts) > 0 {
			o.ReceivedGifts = make([]uint32, len(m.ReceivedGifts))
			copy(o.ReceivedGifts, m.ReceivedGifts)
		}
		return o
	}
	return nil
}

func InitCardPoolInfo() *CardPoolInfo {
	m := &CardPoolInfo{}
	m.FixNilFields()
	return m
}
func (m *CardPoolInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *FastDrawParams) Clone() *FastDrawParams {
	if m != nil {
		o := &FastDrawParams{}
		o.PoolId = m.PoolId
		o.Times = m.Times
		o.GuaranteeTimes = m.GuaranteeTimes
		o.DrawTimes = m.DrawTimes
		o.FreeTimes = m.FreeTimes
		o.ThroneDrawMaxTimesFreeUsedTimes = m.ThroneDrawMaxTimesFreeUsedTimes
		return o
	}
	return nil
}

func InitFastDrawParams() *FastDrawParams {
	m := &FastDrawParams{}
	m.FixNilFields()
	return m
}
func (m *FastDrawParams) FixNilFields() {
	if m != nil {

	}
}
func (m *BigAwardRecord) Clone() *BigAwardRecord {
	if m != nil {
		o := &BigAwardRecord{}
		o.UserId = m.UserId
		o.UserName = m.UserName
		o.PoolId = m.PoolId
		o.Award = m.Award.Clone()
		return o
	}
	return nil
}

func InitBigAwardRecord() *BigAwardRecord {
	m := &BigAwardRecord{}
	m.FixNilFields()
	return m
}
func (m *BigAwardRecord) FixNilFields() {
	if m != nil {

		if m.Award == nil {
			m.Award = &Resource{}
		}
		m.Award.FixNilFields()

	}
}
func (m *HistoryCardDraw) Clone() *HistoryCardDraw {
	if m != nil {
		o := &HistoryCardDraw{}
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHistoryCardDraw() *HistoryCardDraw {
	m := &HistoryCardDraw{}
	m.FixNilFields()
	return m
}
func (m *HistoryCardDraw) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *WayGiftbag) Clone() *WayGiftbag {
	if m != nil {
		o := &WayGiftbag{}
		o.Type = m.Type
		o.Level = m.Level
		o.Count = m.Count
		o.Time = m.Time
		if len(m.Progresses) > 0 {
			o.Progresses = make([]*BuyProgress, len(m.Progresses))
			for k, e := range m.Progresses {
				o.Progresses[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitWayGiftbag() *WayGiftbag {
	m := &WayGiftbag{}
	m.FixNilFields()
	return m
}
func (m *WayGiftbag) FixNilFields() {
	if m != nil {

		for _, itor := range m.Progresses {
			itor.FixNilFields()
		}

	}
}
func (m *PicturePage) Clone() *PicturePage {
	if m != nil {
		o := &PicturePage{}
		o.Id = m.Id
		o.Stage = m.Stage
		o.Level = m.Level
		if len(m.SkillGroupLevels) > 0 {
			o.SkillGroupLevels = make(map[uint32]uint32, len(m.SkillGroupLevels))
			for k, e := range m.SkillGroupLevels {
				o.SkillGroupLevels[k] = e
			}
		}
		return o
	}
	return nil
}

func InitPicturePage() *PicturePage {
	m := &PicturePage{}
	m.FixNilFields()
	return m
}
func (m *PicturePage) FixNilFields() {
	if m != nil {

		if m.SkillGroupLevels == nil {
			m.SkillGroupLevels = make(map[uint32]uint32)
		}

	}
}
func (m *PictureBook) Clone() *PictureBook {
	if m != nil {
		o := &PictureBook{}
		o.Type = m.Type
		o.Level = m.Level
		o.Exp = m.Exp
		if len(m.Pages) > 0 {
			o.Pages = make(map[uint32]*PicturePage, len(m.Pages))
			for k, e := range m.Pages {
				o.Pages[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPictureBook() *PictureBook {
	m := &PictureBook{}
	m.FixNilFields()
	return m
}
func (m *PictureBook) FixNilFields() {
	if m != nil {

		if m.Pages == nil {
			m.Pages = make(map[uint32]*PicturePage)
		}
		for _, itor := range m.Pages {
			itor.FixNilFields()
		}

	}
}
func (m *AlternateItemInfo) Clone() *AlternateItemInfo {
	if m != nil {
		o := &AlternateItemInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.JoinType = m.JoinType
		o.JoinValue = m.JoinValue
		o.JoinSize = m.JoinSize
		o.ExchangeType = m.ExchangeType
		o.ExchangeValue = m.ExchangeValue
		o.ExchangeSize = m.ExchangeSize
		return o
	}
	return nil
}

func InitAlternateItemInfo() *AlternateItemInfo {
	m := &AlternateItemInfo{}
	m.FixNilFields()
	return m
}
func (m *AlternateItemInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *AlternatePreviewInfo) Clone() *AlternatePreviewInfo {
	if m != nil {
		o := &AlternatePreviewInfo{}
		o.Id = m.Id
		o.StartTime = m.StartTime
		if len(m.Orders) > 0 {
			o.Orders = make([]uint32, len(m.Orders))
			copy(o.Orders, m.Orders)
		}
		o.ServerTimeLimit = m.ServerTimeLimit
		o.ActTime = m.ActTime
		o.Interval = m.Interval
		return o
	}
	return nil
}

func InitAlternatePreviewInfo() *AlternatePreviewInfo {
	m := &AlternatePreviewInfo{}
	m.FixNilFields()
	return m
}
func (m *AlternatePreviewInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *AlternateActivityInfo) Clone() *AlternateActivityInfo {
	if m != nil {
		o := &AlternateActivityInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.ActType = m.ActType
		o.FreeTimes = m.FreeTimes
		o.MaxTimes = m.MaxTimes
		o.GiftId = m.GiftId
		o.RankTimeType = m.RankTimeType
		o.RankEndTime = m.RankEndTime
		o.DailyLimit = m.DailyLimit
		o.Description = m.Description
		o.Intro = m.Intro
		o.RateDes = m.RateDes
		o.RateDes1 = m.RateDes1
		o.RateDes2 = m.RateDes2
		o.Level = m.Level
		o.ServerLimit = m.ServerLimit
		o.TimeType = m.TimeType
		o.OpenTime = m.OpenTime
		o.EndTime = m.EndTime
		o.Offline = m.Offline
		o.PageId = m.PageId
		if len(m.Shows) > 0 {
			o.Shows = make([]*Resource, len(m.Shows))
			for k, e := range m.Shows {
				o.Shows[k] = e.Clone()
			}
		}
		o.RankHide = m.RankHide
		o.DisableTurnAward = m.DisableTurnAward
		o.PlayType = m.PlayType
		if len(m.TreasureShows) > 0 {
			o.TreasureShows = make([]*AlternateTreasureShow, len(m.TreasureShows))
			for k, e := range m.TreasureShows {
				o.TreasureShows[k] = e.Clone()
			}
		}
		if len(m.Transfers) > 0 {
			o.Transfers = make([]*AlternateTransfer, len(m.Transfers))
			for k, e := range m.Transfers {
				o.Transfers[k] = e.Clone()
			}
		}
		o.TransferSpec = m.TransferSpec.Clone()
		o.ShowType = m.ShowType
		o.ShowId = m.ShowId
		o.TreasureName = m.TreasureName
		o.TransferType = m.TransferType
		o.TransferValue = m.TransferValue
		return o
	}
	return nil
}

func InitAlternateActivityInfo() *AlternateActivityInfo {
	m := &AlternateActivityInfo{}
	m.FixNilFields()
	return m
}
func (m *AlternateActivityInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Shows {
			itor.FixNilFields()
		}

		for _, itor := range m.TreasureShows {
			itor.FixNilFields()
		}

		for _, itor := range m.Transfers {
			itor.FixNilFields()
		}

		if m.TransferSpec == nil {
			m.TransferSpec = &AlternateTransferSpec{}
		}
		m.TransferSpec.FixNilFields()

	}
}
func (m *AlternateTreasureShow) Clone() *AlternateTreasureShow {
	if m != nil {
		o := &AlternateTreasureShow{}
		o.ShowType = m.ShowType
		o.ShowId = m.ShowId
		o.TreasureName = m.TreasureName
		return o
	}
	return nil
}

func InitAlternateTreasureShow() *AlternateTreasureShow {
	m := &AlternateTreasureShow{}
	m.FixNilFields()
	return m
}
func (m *AlternateTreasureShow) FixNilFields() {
	if m != nil {

	}
}
func (m *AlternateTransfer) Clone() *AlternateTransfer {
	if m != nil {
		o := &AlternateTransfer{}
		o.Type = m.Type
		o.Value = m.Value
		o.Name = m.Name
		o.Icon = m.Icon
		return o
	}
	return nil
}

func InitAlternateTransfer() *AlternateTransfer {
	m := &AlternateTransfer{}
	m.FixNilFields()
	return m
}
func (m *AlternateTransfer) FixNilFields() {
	if m != nil {

	}
}
func (m *AlternateTransferSpec) Clone() *AlternateTransferSpec {
	if m != nil {
		o := &AlternateTransferSpec{}
		o.Type = m.Type
		o.Value = m.Value
		o.Name = m.Name
		return o
	}
	return nil
}

func InitAlternateTransferSpec() *AlternateTransferSpec {
	m := &AlternateTransferSpec{}
	m.FixNilFields()
	return m
}
func (m *AlternateTransferSpec) FixNilFields() {
	if m != nil {

	}
}
func (m *AlternateExchangeInfo) Clone() *AlternateExchangeInfo {
	if m != nil {
		o := &AlternateExchangeInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Floor = m.Floor
		o.UnlockRequire = m.UnlockRequire
		o.Reward = m.Reward.Clone()
		o.ExchangeNum = m.ExchangeNum
		o.Times = m.Times
		o.Tag = m.Tag
		o.LevelMin = m.LevelMin
		o.LevelMax = m.LevelMax
		o.Order = m.Order
		return o
	}
	return nil
}

func InitAlternateExchangeInfo() *AlternateExchangeInfo {
	m := &AlternateExchangeInfo{}
	m.FixNilFields()
	return m
}
func (m *AlternateExchangeInfo) FixNilFields() {
	if m != nil {

		if m.Reward == nil {
			m.Reward = &Resource{}
		}
		m.Reward.FixNilFields()

	}
}
func (m *AlternateExchangeRewardInfo) Clone() *AlternateExchangeRewardInfo {
	if m != nil {
		o := &AlternateExchangeRewardInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Require = m.Require
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitAlternateExchangeRewardInfo() *AlternateExchangeRewardInfo {
	m := &AlternateExchangeRewardInfo{}
	m.FixNilFields()
	return m
}
func (m *AlternateExchangeRewardInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *AlternateRankAwardInfo) Clone() *AlternateRankAwardInfo {
	if m != nil {
		o := &AlternateRankAwardInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.RankHigh = m.RankHigh
		o.RankLow = m.RankLow
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitAlternateRankAwardInfo() *AlternateRankAwardInfo {
	m := &AlternateRankAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *AlternateRankAwardInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *AlternateRewardGroupInfo) Clone() *AlternateRewardGroupInfo {
	if m != nil {
		o := &AlternateRewardGroupInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Group = m.Group
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.Rate = m.Rate
		return o
	}
	return nil
}

func InitAlternateRewardGroupInfo() *AlternateRewardGroupInfo {
	m := &AlternateRewardGroupInfo{}
	m.FixNilFields()
	return m
}
func (m *AlternateRewardGroupInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *AlternateTurnsInfo) Clone() *AlternateTurnsInfo {
	if m != nil {
		o := &AlternateTurnsInfo{}
		o.Id = m.Id
		o.ActId = m.ActId
		o.Turns = m.Turns
		o.TimesRequire = m.TimesRequire
		if len(m.Rewards) > 0 {
			o.Rewards = make([]*Resource, len(m.Rewards))
			for k, e := range m.Rewards {
				o.Rewards[k] = e.Clone()
			}
		}
		o.TurnsAward = m.TurnsAward
		return o
	}
	return nil
}

func InitAlternateTurnsInfo() *AlternateTurnsInfo {
	m := &AlternateTurnsInfo{}
	m.FixNilFields()
	return m
}
func (m *AlternateTurnsInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Rewards {
			itor.FixNilFields()
		}

	}
}
func (m *AlternateTurnLog) Clone() *AlternateTurnLog {
	if m != nil {
		o := &AlternateTurnLog{}
		o.Time = m.Time
		o.Count = m.Count
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitAlternateTurnLog() *AlternateTurnLog {
	m := &AlternateTurnLog{}
	m.FixNilFields()
	return m
}
func (m *AlternateTurnLog) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *AlternateTurn) Clone() *AlternateTurn {
	if m != nil {
		o := &AlternateTurn{}
		o.TotalTimes = m.TotalTimes
		o.ExchangeTotalCost = m.ExchangeTotalCost
		o.ProtectTimes = m.ProtectTimes
		o.DailyUsedTimes = m.DailyUsedTimes
		o.DailyUsedFreeTimes = m.DailyUsedFreeTimes
		o.BigCount = m.BigCount
		o.SmallCount = m.SmallCount
		if len(m.LocalTurnAwarded) > 0 {
			o.LocalTurnAwarded = make([]uint32, len(m.LocalTurnAwarded))
			copy(o.LocalTurnAwarded, m.LocalTurnAwarded)
		}
		if len(m.GlobalTurnAwarded) > 0 {
			o.GlobalTurnAwarded = make([]uint32, len(m.GlobalTurnAwarded))
			copy(o.GlobalTurnAwarded, m.GlobalTurnAwarded)
		}
		if len(m.ExchangeAwarded) > 0 {
			o.ExchangeAwarded = make([]uint32, len(m.ExchangeAwarded))
			copy(o.ExchangeAwarded, m.ExchangeAwarded)
		}
		if len(m.ExchangeTimes) > 0 {
			o.ExchangeTimes = make(map[uint32]uint32, len(m.ExchangeTimes))
			for k, e := range m.ExchangeTimes {
				o.ExchangeTimes[k] = e
			}
		}
		return o
	}
	return nil
}

func InitAlternateTurn() *AlternateTurn {
	m := &AlternateTurn{}
	m.FixNilFields()
	return m
}
func (m *AlternateTurn) FixNilFields() {
	if m != nil {

		if m.ExchangeTimes == nil {
			m.ExchangeTimes = make(map[uint32]uint32)
		}

	}
}
func (m *AlternateTurnConf) Clone() *AlternateTurnConf {
	if m != nil {
		o := &AlternateTurnConf{}
		if len(m.ServerVersion) > 0 {
			o.ServerVersion = make(map[uint32]int64, len(m.ServerVersion))
			for k, e := range m.ServerVersion {
				o.ServerVersion[k] = e
			}
		}
		if len(m.ActivityInfos) > 0 {
			o.ActivityInfos = make([]*AlternateActivityInfo, len(m.ActivityInfos))
			for k, e := range m.ActivityInfos {
				o.ActivityInfos[k] = e.Clone()
			}
		}
		if len(m.ExchangeInfos) > 0 {
			o.ExchangeInfos = make([]*AlternateExchangeInfo, len(m.ExchangeInfos))
			for k, e := range m.ExchangeInfos {
				o.ExchangeInfos[k] = e.Clone()
			}
		}
		if len(m.ExchangeRewardInfos) > 0 {
			o.ExchangeRewardInfos = make([]*AlternateExchangeRewardInfo, len(m.ExchangeRewardInfos))
			for k, e := range m.ExchangeRewardInfos {
				o.ExchangeRewardInfos[k] = e.Clone()
			}
		}
		if len(m.RankAwardInfos) > 0 {
			o.RankAwardInfos = make([]*AlternateRankAwardInfo, len(m.RankAwardInfos))
			for k, e := range m.RankAwardInfos {
				o.RankAwardInfos[k] = e.Clone()
			}
		}
		if len(m.RewardGroupInfos) > 0 {
			o.RewardGroupInfos = make([]*AlternateRewardGroupInfo, len(m.RewardGroupInfos))
			for k, e := range m.RewardGroupInfos {
				o.RewardGroupInfos[k] = e.Clone()
			}
		}
		if len(m.TurnsInfos) > 0 {
			o.TurnsInfos = make([]*AlternateTurnsInfo, len(m.TurnsInfos))
			for k, e := range m.TurnsInfos {
				o.TurnsInfos[k] = e.Clone()
			}
		}
		if len(m.PreviewInfos) > 0 {
			o.PreviewInfos = make([]*AlternatePreviewInfo, len(m.PreviewInfos))
			for k, e := range m.PreviewInfos {
				o.PreviewInfos[k] = e.Clone()
			}
		}
		if len(m.ItemInfos) > 0 {
			o.ItemInfos = make([]*AlternateItemInfo, len(m.ItemInfos))
			for k, e := range m.ItemInfos {
				o.ItemInfos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitAlternateTurnConf() *AlternateTurnConf {
	m := &AlternateTurnConf{}
	m.FixNilFields()
	return m
}
func (m *AlternateTurnConf) FixNilFields() {
	if m != nil {

		if m.ServerVersion == nil {
			m.ServerVersion = make(map[uint32]int64)
		}

		for _, itor := range m.ActivityInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.ExchangeInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.ExchangeRewardInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.RankAwardInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.RewardGroupInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.TurnsInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.PreviewInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.ItemInfos {
			itor.FixNilFields()
		}

	}
}
func (m *TreasureCall) Clone() *TreasureCall {
	if m != nil {
		o := &TreasureCall{}
		o.PoolId = m.PoolId
		o.Reiki = m.Reiki
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		o.Awards = m.Awards.Clone()
		return o
	}
	return nil
}

func InitTreasureCall() *TreasureCall {
	m := &TreasureCall{}
	m.FixNilFields()
	return m
}
func (m *TreasureCall) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

		if m.Awards == nil {
			m.Awards = &ReceivedAward{}
		}
		m.Awards.FixNilFields()

	}
}
func (m *Treasure) Clone() *Treasure {
	if m != nil {
		o := &Treasure{}
		o.Id = m.Id
		o.StarId = m.StarId
		o.Energy = m.Energy
		if len(m.PetAdditions) > 0 {
			o.PetAdditions = make([]*TreasurePetAddition, len(m.PetAdditions))
			for k, e := range m.PetAdditions {
				o.PetAdditions[k] = e.Clone()
			}
		}
		o.RefreshTime = m.RefreshTime
		return o
	}
	return nil
}

func InitTreasure() *Treasure {
	m := &Treasure{}
	m.FixNilFields()
	return m
}
func (m *Treasure) FixNilFields() {
	if m != nil {

		for _, itor := range m.PetAdditions {
			itor.FixNilFields()
		}

	}
}
func (m *TreasurePetAddition) Clone() *TreasurePetAddition {
	if m != nil {
		o := &TreasurePetAddition{}
		o.Id = m.Id
		o.TreasureInfoId = m.TreasureInfoId
		o.StartTime = m.StartTime
		return o
	}
	return nil
}

func InitTreasurePetAddition() *TreasurePetAddition {
	m := &TreasurePetAddition{}
	m.FixNilFields()
	return m
}
func (m *TreasurePetAddition) FixNilFields() {
	if m != nil {

	}
}
func (m *RelicsBusinessBox) Clone() *RelicsBusinessBox {
	if m != nil {
		o := &RelicsBusinessBox{}
		if len(m.Grids) > 0 {
			o.Grids = make([]*SmallKV, len(m.Grids))
			for k, e := range m.Grids {
				o.Grids[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitRelicsBusinessBox() *RelicsBusinessBox {
	m := &RelicsBusinessBox{}
	m.FixNilFields()
	return m
}
func (m *RelicsBusinessBox) FixNilFields() {
	if m != nil {

		for _, itor := range m.Grids {
			itor.FixNilFields()
		}

	}
}
func (m *RelicsEnemy) Clone() *RelicsEnemy {
	if m != nil {
		o := &RelicsEnemy{}
		o.Id = m.Id
		o.Type = m.Type
		o.ServerId = m.ServerId
		o.Name = m.Name
		o.Level = m.Level
		o.Power = m.Power
		o.Dead = m.Dead
		o.Mate = m.Mate
		o.Quality = m.Quality
		o.Difficulty = m.Difficulty
		return o
	}
	return nil
}

func InitRelicsEnemy() *RelicsEnemy {
	m := &RelicsEnemy{}
	m.FixNilFields()
	return m
}
func (m *RelicsEnemy) FixNilFields() {
	if m != nil {

	}
}
func (m *RelicsNode) Clone() *RelicsNode {
	if m != nil {
		o := &RelicsNode{}
		o.Id = m.Id
		o.Type = m.Type
		o.Enemy = m.Enemy.Clone()
		o.Box = m.Box.Clone()
		return o
	}
	return nil
}

func InitRelicsNode() *RelicsNode {
	m := &RelicsNode{}
	m.FixNilFields()
	return m
}
func (m *RelicsNode) FixNilFields() {
	if m != nil {

		if m.Enemy == nil {
			m.Enemy = &RelicsEnemy{}
		}
		m.Enemy.FixNilFields()

		if m.Box == nil {
			m.Box = &RelicsBusinessBox{}
		}
		m.Box.FixNilFields()

	}
}
func (m *Relics) Clone() *Relics {
	if m != nil {
		o := &Relics{}
		o.Id = m.Id
		if len(m.Nodes) > 0 {
			o.Nodes = make(map[uint32]*RelicsNode, len(m.Nodes))
			for k, e := range m.Nodes {
				o.Nodes[k] = e.Clone()
			}
		}
		if len(m.Worship) > 0 {
			o.Worship = make([]uint32, len(m.Worship))
			copy(o.Worship, m.Worship)
		}
		o.HitPower = m.HitPower
		o.DailyResetTime = m.DailyResetTime
		o.WeeklyResetTime = m.WeeklyResetTime
		if len(m.BeatNodes) > 0 {
			o.BeatNodes = make([]uint32, len(m.BeatNodes))
			copy(o.BeatNodes, m.BeatNodes)
		}
		return o
	}
	return nil
}

func InitRelics() *Relics {
	m := &Relics{}
	m.FixNilFields()
	return m
}
func (m *Relics) FixNilFields() {
	if m != nil {

		if m.Nodes == nil {
			m.Nodes = make(map[uint32]*RelicsNode)
		}
		for _, itor := range m.Nodes {
			itor.FixNilFields()
		}

	}
}
func (m *RelicsTask) Clone() *RelicsTask {
	if m != nil {
		o := &RelicsTask{}
		o.Awards = m.Awards.Clone()
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitRelicsTask() *RelicsTask {
	m := &RelicsTask{}
	m.FixNilFields()
	return m
}
func (m *RelicsTask) FixNilFields() {
	if m != nil {

		if m.Awards == nil {
			m.Awards = &ReceivedAward{}
		}
		m.Awards.FixNilFields()

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *RelicsCommon) Clone() *RelicsCommon {
	if m != nil {
		o := &RelicsCommon{}
		o.WeeklyTasks = m.WeeklyTasks.Clone()
		o.PermanentTasks = m.PermanentTasks.Clone()
		o.Score = m.Score
		o.ScoreAwards = m.ScoreAwards.Clone()
		if len(m.Skills) > 0 {
			o.Skills = make(map[uint32]uint32, len(m.Skills))
			for k, e := range m.Skills {
				o.Skills[k] = e
			}
		}
		o.Coin = m.Coin
		o.Level = m.Level
		return o
	}
	return nil
}

func InitRelicsCommon() *RelicsCommon {
	m := &RelicsCommon{}
	m.FixNilFields()
	return m
}
func (m *RelicsCommon) FixNilFields() {
	if m != nil {

		if m.WeeklyTasks == nil {
			m.WeeklyTasks = &RelicsTask{}
		}
		m.WeeklyTasks.FixNilFields()

		if m.PermanentTasks == nil {
			m.PermanentTasks = &RelicsTask{}
		}
		m.PermanentTasks.FixNilFields()

		if m.ScoreAwards == nil {
			m.ScoreAwards = &ReceivedAward{}
		}
		m.ScoreAwards.FixNilFields()

		if m.Skills == nil {
			m.Skills = make(map[uint32]uint32)
		}

	}
}
func (m *TimeRank) Clone() *TimeRank {
	if m != nil {
		o := &TimeRank{}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.AwardedTaskIds) > 0 {
			o.AwardedTaskIds = make([]uint32, len(m.AwardedTaskIds))
			copy(o.AwardedTaskIds, m.AwardedTaskIds)
		}
		return o
	}
	return nil
}

func InitTimeRank() *TimeRank {
	m := &TimeRank{}
	m.FixNilFields()
	return m
}
func (m *TimeRank) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *Horcrux) Clone() *Horcrux {
	if m != nil {
		o := &Horcrux{}
		o.UniqueId = m.UniqueId
		o.BaseId = m.BaseId
		o.Star = m.Star
		if len(m.StarCosts) > 0 {
			o.StarCosts = make([]*ConsumeHorcrux, len(m.StarCosts))
			for k, e := range m.StarCosts {
				o.StarCosts[k] = e.Clone()
			}
		}
		if len(m.StarSkills) > 0 {
			o.StarSkills = make([]*SmallKV, len(m.StarSkills))
			for k, e := range m.StarSkills {
				o.StarSkills[k] = e.Clone()
			}
		}
		o.InheritStage = m.InheritStage
		o.Lock = m.Lock
		return o
	}
	return nil
}

func InitHorcrux() *Horcrux {
	m := &Horcrux{}
	m.FixNilFields()
	return m
}
func (m *Horcrux) FixNilFields() {
	if m != nil {

		for _, itor := range m.StarCosts {
			itor.FixNilFields()
		}

		for _, itor := range m.StarSkills {
			itor.FixNilFields()
		}

	}
}
func (m *ConsumeHorcrux) Clone() *ConsumeHorcrux {
	if m != nil {
		o := &ConsumeHorcrux{}
		o.BaseId = m.BaseId
		o.Star = m.Star
		o.InheritStage = m.InheritStage
		return o
	}
	return nil
}

func InitConsumeHorcrux() *ConsumeHorcrux {
	m := &ConsumeHorcrux{}
	m.FixNilFields()
	return m
}
func (m *ConsumeHorcrux) FixNilFields() {
	if m != nil {

	}
}
func (m *HorcruxDownPos) Clone() *HorcruxDownPos {
	if m != nil {
		o := &HorcruxDownPos{}
		o.TeamType = m.TeamType
		o.Pos = m.Pos
		return o
	}
	return nil
}

func InitHorcruxDownPos() *HorcruxDownPos {
	m := &HorcruxDownPos{}
	m.FixNilFields()
	return m
}
func (m *HorcruxDownPos) FixNilFields() {
	if m != nil {

	}
}
func (m *HorcruxDown) Clone() *HorcruxDown {
	if m != nil {
		o := &HorcruxDown{}
		o.Horcrux = m.Horcrux.Clone()
		if len(m.Downs) > 0 {
			o.Downs = make([]*HorcruxDownPos, len(m.Downs))
			for k, e := range m.Downs {
				o.Downs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHorcruxDown() *HorcruxDown {
	m := &HorcruxDown{}
	m.FixNilFields()
	return m
}
func (m *HorcruxDown) FixNilFields() {
	if m != nil {

		if m.Horcrux == nil {
			m.Horcrux = &Horcrux{}
		}
		m.Horcrux.FixNilFields()

		for _, itor := range m.Downs {
			itor.FixNilFields()
		}

	}
}
func (m *HorcruxStarParam) Clone() *HorcruxStarParam {
	if m != nil {
		o := &HorcruxStarParam{}
		o.Self = m.Self
		if len(m.Consumes) > 0 {
			o.Consumes = make(map[uint32]*Uint64S, len(m.Consumes))
			for k, e := range m.Consumes {
				o.Consumes[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHorcruxStarParam() *HorcruxStarParam {
	m := &HorcruxStarParam{}
	m.FixNilFields()
	return m
}
func (m *HorcruxStarParam) FixNilFields() {
	if m != nil {

		if m.Consumes == nil {
			m.Consumes = make(map[uint32]*Uint64S)
		}
		for _, itor := range m.Consumes {
			itor.FixNilFields()
		}

	}
}
func (m *FormationHorcrux) Clone() *FormationHorcrux {
	if m != nil {
		o := &FormationHorcrux{}
		o.Id = m.Id
		o.BaseId = m.BaseId
		o.Level = m.Level
		o.YokeId = m.YokeId
		o.YokeActive = m.YokeActive
		return o
	}
	return nil
}

func InitFormationHorcrux() *FormationHorcrux {
	m := &FormationHorcrux{}
	m.FixNilFields()
	return m
}
func (m *FormationHorcrux) FixNilFields() {
	if m != nil {

	}
}
func (m *Background) Clone() *Background {
	if m != nil {
		o := &Background{}
		if len(m.ActiveIds) > 0 {
			o.ActiveIds = make([]uint32, len(m.ActiveIds))
			copy(o.ActiveIds, m.ActiveIds)
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make([]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.ExploreProgs) > 0 {
			o.ExploreProgs = make(map[uint32]uint32, len(m.ExploreProgs))
			for k, e := range m.ExploreProgs {
				o.ExploreProgs[k] = e
			}
		}
		return o
	}
	return nil
}

func InitBackground() *Background {
	m := &Background{}
	m.FixNilFields()
	return m
}
func (m *Background) FixNilFields() {
	if m != nil {

		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

		if m.ExploreProgs == nil {
			m.ExploreProgs = make(map[uint32]uint32)
		}

	}
}
func (m *BoardNpc) Clone() *BoardNpc {
	if m != nil {
		o := &BoardNpc{}
		if len(m.ActiveIds) > 0 {
			o.ActiveIds = make([]uint32, len(m.ActiveIds))
			copy(o.ActiveIds, m.ActiveIds)
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make([]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBoardNpc() *BoardNpc {
	m := &BoardNpc{}
	m.FixNilFields()
	return m
}
func (m *BoardNpc) FixNilFields() {
	if m != nil {

		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *LodeInfo) Clone() *LodeInfo {
	if m != nil {
		o := &LodeInfo{}
		o.LodeId = m.LodeId
		o.PlayerCount = m.PlayerCount
		o.LeagueCount = m.LeagueCount
		o.Multi = m.Multi
		o.Owner = m.Owner.Clone()
		if len(m.Production) > 0 {
			o.Production = make([]*Resource, len(m.Production))
			for k, e := range m.Production {
				o.Production[k] = e.Clone()
			}
		}
		o.LeaguePlayerCount = m.LeaguePlayerCount
		o.GuardCount = m.GuardCount
		return o
	}
	return nil
}

func InitLodeInfo() *LodeInfo {
	m := &LodeInfo{}
	m.FixNilFields()
	return m
}
func (m *LodeInfo) FixNilFields() {
	if m != nil {

		if m.Owner == nil {
			m.Owner = &LeagueSnapshot{}
		}
		m.Owner.FixNilFields()

		for _, itor := range m.Production {
			itor.FixNilFields()
		}

	}
}
func (m *LodePlayer) Clone() *LodePlayer {
	if m != nil {
		o := &LodePlayer{}
		o.User = m.User.Clone()
		o.Mp = m.Mp
		o.Motto = m.Motto
		return o
	}
	return nil
}

func InitLodePlayer() *LodePlayer {
	m := &LodePlayer{}
	m.FixNilFields()
	return m
}
func (m *LodePlayer) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *LodeFightLog) Clone() *LodeFightLog {
	if m != nil {
		o := &LodeFightLog{}
		o.Win = m.Win
		o.Atk = m.Atk
		o.Def = m.Def
		o.AtkCostMp = m.AtkCostMp
		o.DefCostMp = m.DefCostMp
		o.AtkMp = m.AtkMp
		o.DefMp = m.DefMp
		o.FightTime = m.FightTime
		o.GuardFight = m.GuardFight
		return o
	}
	return nil
}

func InitLodeFightLog() *LodeFightLog {
	m := &LodeFightLog{}
	m.FixNilFields()
	return m
}
func (m *LodeFightLog) FixNilFields() {
	if m != nil {

	}
}
func (m *LodeDeportRank) Clone() *LodeDeportRank {
	if m != nil {
		o := &LodeDeportRank{}
		o.User = m.User.Clone()
		o.DeportCount = m.DeportCount
		o.DailyDeportCount = m.DailyDeportCount
		return o
	}
	return nil
}

func InitLodeDeportRank() *LodeDeportRank {
	m := &LodeDeportRank{}
	m.FixNilFields()
	return m
}
func (m *LodeDeportRank) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *LodeEvent) Clone() *LodeEvent {
	if m != nil {
		o := &LodeEvent{}
		o.Type = m.Type
		o.UserName = m.UserName
		o.LeagueName = m.LeagueName
		o.LeagueId = m.LeagueId
		o.ServerId = m.ServerId
		o.UserName2 = m.UserName2
		o.LeagueName2 = m.LeagueName2
		o.LeagueId2 = m.LeagueId2
		o.ServerId2 = m.ServerId2
		o.PlayerCount = m.PlayerCount
		o.LeagueCount = m.LeagueCount
		o.Time = m.Time
		return o
	}
	return nil
}

func InitLodeEvent() *LodeEvent {
	m := &LodeEvent{}
	m.FixNilFields()
	return m
}
func (m *LodeEvent) FixNilFields() {
	if m != nil {

	}
}
func (m *LodeGuardUser) Clone() *LodeGuardUser {
	if m != nil {
		o := &LodeGuardUser{}
		o.Snap = m.Snap.Clone()
		o.GuardSlot = m.GuardSlot
		o.Mp = m.Mp
		o.DeportCount = m.DeportCount
		o.GuardDailyFightTimes = m.GuardDailyFightTimes
		return o
	}
	return nil
}

func InitLodeGuardUser() *LodeGuardUser {
	m := &LodeGuardUser{}
	m.FixNilFields()
	return m
}
func (m *LodeGuardUser) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *HuaweiSubscribe) Clone() *HuaweiSubscribe {
	if m != nil {
		o := &HuaweiSubscribe{}
		if len(m.Subs) > 0 {
			o.Subs = make([]*HuaweiSubscription, len(m.Subs))
			for k, e := range m.Subs {
				o.Subs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitHuaweiSubscribe() *HuaweiSubscribe {
	m := &HuaweiSubscribe{}
	m.FixNilFields()
	return m
}
func (m *HuaweiSubscribe) FixNilFields() {
	if m != nil {

		for _, itor := range m.Subs {
			itor.FixNilFields()
		}

	}
}
func (m *HuaweiSubscription) Clone() *HuaweiSubscription {
	if m != nil {
		o := &HuaweiSubscription{}
		o.SubId = m.SubId
		o.ExpireDayResetTm = m.ExpireDayResetTm
		o.LastDailyAwardTm = m.LastDailyAwardTm
		o.FirstAwardSend = m.FirstAwardSend
		return o
	}
	return nil
}

func InitHuaweiSubscription() *HuaweiSubscription {
	m := &HuaweiSubscription{}
	m.FixNilFields()
	return m
}
func (m *HuaweiSubscription) FixNilFields() {
	if m != nil {

	}
}
func (m *FaithMyBase) Clone() *FaithMyBase {
	if m != nil {
		o := &FaithMyBase{}
		o.Score = m.Score
		o.ContinueWinNum = m.ContinueWinNum
		o.LocalRank = m.LocalRank
		o.CrossRank = m.CrossRank
		o.UpRankNeedScore = m.UpRankNeedScore
		o.UpRankTo = m.UpRankTo
		o.LeftChallengeNum = m.LeftChallengeNum
		o.ChallengedEnemyNum = m.ChallengedEnemyNum
		o.ChallengedBossNum = m.ChallengedBossNum
		o.LastChallengeBossTime = m.LastChallengeBossTime
		if len(m.TaskConditions) > 0 {
			o.TaskConditions = make(map[uint32]*Condition, len(m.TaskConditions))
			for k, e := range m.TaskConditions {
				o.TaskConditions[k] = e.Clone()
			}
		}
		if len(m.AwardTaskIds) > 0 {
			o.AwardTaskIds = make([]uint32, len(m.AwardTaskIds))
			copy(o.AwardTaskIds, m.AwardTaskIds)
		}
		o.LastChallengeEnemyTime = m.LastChallengeEnemyTime
		if len(m.EnemyFightTimes) > 0 {
			o.EnemyFightTimes = make([]*PairU32, len(m.EnemyFightTimes))
			for k, e := range m.EnemyFightTimes {
				o.EnemyFightTimes[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitFaithMyBase() *FaithMyBase {
	m := &FaithMyBase{}
	m.FixNilFields()
	return m
}
func (m *FaithMyBase) FixNilFields() {
	if m != nil {

		if m.TaskConditions == nil {
			m.TaskConditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.TaskConditions {
			itor.FixNilFields()
		}

		for _, itor := range m.EnemyFightTimes {
			itor.FixNilFields()
		}

	}
}
func (m *FaithEnemy) Clone() *FaithEnemy {
	if m != nil {
		o := &FaithEnemy{}
		o.Snap = m.Snap.Clone()
		o.ContinueWinNum = m.ContinueWinNum
		o.Score = m.Score
		o.CrossRank = m.CrossRank
		return o
	}
	return nil
}

func InitFaithEnemy() *FaithEnemy {
	m := &FaithEnemy{}
	m.FixNilFields()
	return m
}
func (m *FaithEnemy) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *FaithEnemyBrief) Clone() *FaithEnemyBrief {
	if m != nil {
		o := &FaithEnemyBrief{}
		o.UserId = m.UserId
		o.ContinueWinNum = m.ContinueWinNum
		o.Score = m.Score
		o.CrossRank = m.CrossRank
		return o
	}
	return nil
}

func InitFaithEnemyBrief() *FaithEnemyBrief {
	m := &FaithEnemyBrief{}
	m.FixNilFields()
	return m
}
func (m *FaithEnemyBrief) FixNilFields() {
	if m != nil {

	}
}
func (m *FaithShowUser) Clone() *FaithShowUser {
	if m != nil {
		o := &FaithShowUser{}
		o.Snap = m.Snap.Clone()
		o.Score = m.Score
		return o
	}
	return nil
}

func InitFaithShowUser() *FaithShowUser {
	m := &FaithShowUser{}
	m.FixNilFields()
	return m
}
func (m *FaithShowUser) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *FaithBriefVideo) Clone() *FaithBriefVideo {
	if m != nil {
		o := &FaithBriefVideo{}
		o.Id = m.Id
		o.Time = m.Time
		o.Win = m.Win
		o.Attacker = m.Attacker.Clone()
		o.Defender = m.Defender.Clone()
		o.AttackerScore = m.AttackerScore
		o.AttackerChangeScore = m.AttackerChangeScore
		o.DefenderScore = m.DefenderScore
		o.DefenderChangeScore = m.DefenderChangeScore
		return o
	}
	return nil
}

func InitFaithBriefVideo() *FaithBriefVideo {
	m := &FaithBriefVideo{}
	m.FixNilFields()
	return m
}
func (m *FaithBriefVideo) FixNilFields() {
	if m != nil {

		if m.Attacker == nil {
			m.Attacker = &UserSnapshot{}
		}
		m.Attacker.FixNilFields()

		if m.Defender == nil {
			m.Defender = &UserSnapshot{}
		}
		m.Defender.FixNilFields()

	}
}
func (m *FaithCombatChat) Clone() *FaithCombatChat {
	if m != nil {
		o := &FaithCombatChat{}
		o.Id = m.Id
		o.ServerId1 = m.ServerId1
		o.UserName1 = m.UserName1
		o.ServerId2 = m.ServerId2
		o.UserName2 = m.UserName2
		o.WinNum = m.WinNum
		o.AnnounceId = m.AnnounceId
		return o
	}
	return nil
}

func InitFaithCombatChat() *FaithCombatChat {
	m := &FaithCombatChat{}
	m.FixNilFields()
	return m
}
func (m *FaithCombatChat) FixNilFields() {
	if m != nil {

	}
}
func (m *Auction) Clone() *Auction {
	if m != nil {
		o := &Auction{}
		o.Id = m.Id
		o.AuctionType = m.AuctionType
		o.HouseId = m.HouseId
		if len(m.Goods) > 0 {
			o.Goods = make([]*AuctionGood, len(m.Goods))
			for k, e := range m.Goods {
				o.Goods[k] = e.Clone()
			}
		}
		if len(m.Records) > 0 {
			o.Records = make([]*AuctionRecord, len(m.Records))
			for k, e := range m.Records {
				o.Records[k] = e.Clone()
			}
		}
		o.RankValue = m.RankValue.Clone()
		o.Dividend = m.Dividend
		o.FuncId = m.FuncId
		o.InitFreezeTime = m.InitFreezeTime
		return o
	}
	return nil
}

func InitAuction() *Auction {
	m := &Auction{}
	m.FixNilFields()
	return m
}
func (m *Auction) FixNilFields() {
	if m != nil {

		for _, itor := range m.Goods {
			itor.FixNilFields()
		}

		for _, itor := range m.Records {
			itor.FixNilFields()
		}

		if m.RankValue == nil {
			m.RankValue = &SmallK32V64{}
		}
		m.RankValue.FixNilFields()

	}
}
func (m *AuctionGood) Clone() *AuctionGood {
	if m != nil {
		o := &AuctionGood{}
		o.Id = m.Id
		o.GoodId = m.GoodId
		o.Res = m.Res.Clone()
		o.CompetePrice = m.CompetePrice
		o.Uid = m.Uid
		o.TransactionPrice = m.TransactionPrice
		o.FixedPrice = m.FixedPrice
		o.FreezeTime = m.FreezeTime
		return o
	}
	return nil
}

func InitAuctionGood() *AuctionGood {
	m := &AuctionGood{}
	m.FixNilFields()
	return m
}
func (m *AuctionGood) FixNilFields() {
	if m != nil {

		if m.Res == nil {
			m.Res = &Resource{}
		}
		m.Res.FixNilFields()

	}
}
func (m *AuctionRecord) Clone() *AuctionRecord {
	if m != nil {
		o := &AuctionRecord{}
		o.AuctionId = m.AuctionId
		o.GoodId = m.GoodId
		o.Res = m.Res.Clone()
		o.Time = m.Time
		o.Price = m.Price
		o.State = m.State
		o.Uid = m.Uid
		return o
	}
	return nil
}

func InitAuctionRecord() *AuctionRecord {
	m := &AuctionRecord{}
	m.FixNilFields()
	return m
}
func (m *AuctionRecord) FixNilFields() {
	if m != nil {

		if m.Res == nil {
			m.Res = &Resource{}
		}
		m.Res.FixNilFields()

	}
}
func (m *CreateExtra) Clone() *CreateExtra {
	if m != nil {
		o := &CreateExtra{}
		o.Name = m.Name
		o.CreateTime = m.CreateTime
		return o
	}
	return nil
}

func InitCreateExtra() *CreateExtra {
	m := &CreateExtra{}
	m.FixNilFields()
	return m
}
func (m *CreateExtra) FixNilFields() {
	if m != nil {

	}
}
func (m *LoginExtra) Clone() *LoginExtra {
	if m != nil {
		o := &LoginExtra{}
		o.DeviceId = m.DeviceId
		return o
	}
	return nil
}

func InitLoginExtra() *LoginExtra {
	m := &LoginExtra{}
	m.FixNilFields()
	return m
}
func (m *LoginExtra) FixNilFields() {
	if m != nil {

	}
}
func (m *Rules) Clone() *Rules {
	if m != nil {
		o := &Rules{}
		o.Id = m.Id
		o.Level = m.Level
		o.TierLevel = m.TierLevel
		o.FailCount = m.FailCount
		if len(m.SkillGroupLevels) > 0 {
			o.SkillGroupLevels = make(map[uint32]uint32, len(m.SkillGroupLevels))
			for k, e := range m.SkillGroupLevels {
				o.SkillGroupLevels[k] = e
			}
		}
		return o
	}
	return nil
}

func InitRules() *Rules {
	m := &Rules{}
	m.FixNilFields()
	return m
}
func (m *Rules) FixNilFields() {
	if m != nil {

		if m.SkillGroupLevels == nil {
			m.SkillGroupLevels = make(map[uint32]uint32)
		}

	}
}
func (m *RulesFrontVisit) Clone() *RulesFrontVisit {
	if m != nil {
		o := &RulesFrontVisit{}
		o.Uid = m.Uid
		o.Tm = m.Tm
		o.BeVisitedNumWeekly = m.BeVisitedNumWeekly
		return o
	}
	return nil
}

func InitRulesFrontVisit() *RulesFrontVisit {
	m := &RulesFrontVisit{}
	m.FixNilFields()
	return m
}
func (m *RulesFrontVisit) FixNilFields() {
	if m != nil {

	}
}
func (m *RulesFrontCircle) Clone() *RulesFrontCircle {
	if m != nil {
		o := &RulesFrontCircle{}
		o.Type = m.Type
		o.Level = m.Level
		if len(m.Knights) > 0 {
			o.Knights = make([]uint64, len(m.Knights))
			copy(o.Knights, m.Knights)
		}
		return o
	}
	return nil
}

func InitRulesFrontCircle() *RulesFrontCircle {
	m := &RulesFrontCircle{}
	m.FixNilFields()
	return m
}
func (m *RulesFrontCircle) FixNilFields() {
	if m != nil {

	}
}
func (m *RulesFrontKnightSnapshot) Clone() *RulesFrontKnightSnapshot {
	if m != nil {
		o := &RulesFrontKnightSnapshot{}
		o.BaseId = m.BaseId
		o.Star = m.Star
		o.Skin = m.Skin
		return o
	}
	return nil
}

func InitRulesFrontKnightSnapshot() *RulesFrontKnightSnapshot {
	m := &RulesFrontKnightSnapshot{}
	m.FixNilFields()
	return m
}
func (m *RulesFrontKnightSnapshot) FixNilFields() {
	if m != nil {

	}
}
func (m *RulesFrontCircleSnapshot) Clone() *RulesFrontCircleSnapshot {
	if m != nil {
		o := &RulesFrontCircleSnapshot{}
		o.Type = m.Type
		o.Level = m.Level
		if len(m.Knights) > 0 {
			o.Knights = make([]*RulesFrontKnightSnapshot, len(m.Knights))
			for k, e := range m.Knights {
				o.Knights[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitRulesFrontCircleSnapshot() *RulesFrontCircleSnapshot {
	m := &RulesFrontCircleSnapshot{}
	m.FixNilFields()
	return m
}
func (m *RulesFrontCircleSnapshot) FixNilFields() {
	if m != nil {

		for _, itor := range m.Knights {
			itor.FixNilFields()
		}

	}
}
func (m *RulesFrontUserSnapshot) Clone() *RulesFrontUserSnapshot {
	if m != nil {
		o := &RulesFrontUserSnapshot{}
		o.Uid = m.Uid
		if len(m.Circles) > 0 {
			o.Circles = make([]*RulesFrontCircleSnapshot, len(m.Circles))
			for k, e := range m.Circles {
				o.Circles[k] = e.Clone()
			}
		}
		o.BeVisited = m.BeVisited.Clone()
		return o
	}
	return nil
}

func InitRulesFrontUserSnapshot() *RulesFrontUserSnapshot {
	m := &RulesFrontUserSnapshot{}
	m.FixNilFields()
	return m
}
func (m *RulesFrontUserSnapshot) FixNilFields() {
	if m != nil {

		for _, itor := range m.Circles {
			itor.FixNilFields()
		}

		if m.BeVisited == nil {
			m.BeVisited = &RulesFrontVisit{}
		}
		m.BeVisited.FixNilFields()

	}
}
func (m *RulesFront) Clone() *RulesFront {
	if m != nil {
		o := &RulesFront{}
		o.StartTime = m.StartTime
		o.ExpTime = m.ExpTime
		o.AwardTime = m.AwardTime
		o.RefreshTimeWeekly = m.RefreshTimeWeekly
		o.Exp = m.Exp
		if len(m.Circles) > 0 {
			o.Circles = make([]*RulesFrontCircle, len(m.Circles))
			for k, e := range m.Circles {
				o.Circles[k] = e.Clone()
			}
		}
		o.Visit = m.Visit.Clone()
		if len(m.VisitedUids) > 0 {
			o.VisitedUids = make([]uint64, len(m.VisitedUids))
			copy(o.VisitedUids, m.VisitedUids)
		}
		if len(m.ReceivedAwards) > 0 {
			o.ReceivedAwards = make(map[uint32]*ReceivedAward, len(m.ReceivedAwards))
			for k, e := range m.ReceivedAwards {
				o.ReceivedAwards[k] = e.Clone()
			}
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		o.AwardExp = m.AwardExp
		return o
	}
	return nil
}

func InitRulesFront() *RulesFront {
	m := &RulesFront{}
	m.FixNilFields()
	return m
}
func (m *RulesFront) FixNilFields() {
	if m != nil {

		for _, itor := range m.Circles {
			itor.FixNilFields()
		}

		if m.Visit == nil {
			m.Visit = &RulesFrontVisit{}
		}
		m.Visit.FixNilFields()

		if m.ReceivedAwards == nil {
			m.ReceivedAwards = make(map[uint32]*ReceivedAward)
		}
		for _, itor := range m.ReceivedAwards {
			itor.FixNilFields()
		}

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *EliteTower) Clone() *EliteTower {
	if m != nil {
		o := &EliteTower{}
		o.Stage = m.Stage
		o.Step = m.Step
		o.MaxStep = m.MaxStep
		o.Deads = m.Deads.Clone()
		if len(m.FirstClear) > 0 {
			o.FirstClear = make(map[uint32]uint32, len(m.FirstClear))
			for k, e := range m.FirstClear {
				o.FirstClear[k] = e
			}
		}
		o.DailyZero = m.DailyZero
		o.DailyPassStages = m.DailyPassStages
		return o
	}
	return nil
}

func InitEliteTower() *EliteTower {
	m := &EliteTower{}
	m.FixNilFields()
	return m
}
func (m *EliteTower) FixNilFields() {
	if m != nil {

		if m.Deads == nil {
			m.Deads = &Uint64S{}
		}
		m.Deads.FixNilFields()

		if m.FirstClear == nil {
			m.FirstClear = make(map[uint32]uint32)
		}

	}
}
func (m *LeagueBattleTime) Clone() *LeagueBattleTime {
	if m != nil {
		o := &LeagueBattleTime{}
		o.State = m.State
		o.Season = m.Season
		o.Round = m.Round
		o.SeasonBeginTime = m.SeasonBeginTime
		o.ApplyBeginTime = m.ApplyBeginTime
		o.MatchBeginTime = m.MatchBeginTime
		o.BattleBeginTime = m.BattleBeginTime
		o.BattleEndTime = m.BattleEndTime
		o.SeasonEndTime = m.SeasonEndTime
		return o
	}
	return nil
}

func InitLeagueBattleTime() *LeagueBattleTime {
	m := &LeagueBattleTime{}
	m.FixNilFields()
	return m
}
func (m *LeagueBattleTime) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueBattleMyBase) Clone() *LeagueBattleMyBase {
	if m != nil {
		o := &LeagueBattleMyBase{}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.AwardTaskIds) > 0 {
			o.AwardTaskIds = make([]uint32, len(m.AwardTaskIds))
			copy(o.AwardTaskIds, m.AwardTaskIds)
		}
		if len(m.TeamLeftChallengeNums) > 0 {
			o.TeamLeftChallengeNums = make(map[uint32]uint32, len(m.TeamLeftChallengeNums))
			for k, e := range m.TeamLeftChallengeNums {
				o.TeamLeftChallengeNums[k] = e
			}
		}
		if len(m.TeamRoundScores) > 0 {
			o.TeamRoundScores = make(map[uint32]uint64, len(m.TeamRoundScores))
			for k, e := range m.TeamRoundScores {
				o.TeamRoundScores[k] = e
			}
		}
		if len(m.AwardDefeatedRooms) > 0 {
			o.AwardDefeatedRooms = make([]uint32, len(m.AwardDefeatedRooms))
			copy(o.AwardDefeatedRooms, m.AwardDefeatedRooms)
		}
		o.AwardPkResult = m.AwardPkResult
		o.ShipSkillExpiredTime = m.ShipSkillExpiredTime
		o.ShipSkillUsedTimes = m.ShipSkillUsedTimes
		o.FireTargetRoom = m.FireTargetRoom
		o.FireTargetSetTime = m.FireTargetSetTime
		o.CanAwardPkResult = m.CanAwardPkResult
		o.CanAwardDefeatedRoom = m.CanAwardDefeatedRoom
		return o
	}
	return nil
}

func InitLeagueBattleMyBase() *LeagueBattleMyBase {
	m := &LeagueBattleMyBase{}
	m.FixNilFields()
	return m
}
func (m *LeagueBattleMyBase) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

		if m.TeamLeftChallengeNums == nil {
			m.TeamLeftChallengeNums = make(map[uint32]uint32)
		}

		if m.TeamRoundScores == nil {
			m.TeamRoundScores = make(map[uint32]uint64)
		}

	}
}
func (m *LeagueBattleUser) Clone() *LeagueBattleUser {
	if m != nil {
		o := &LeagueBattleUser{}
		o.MonsterTeamId = m.MonsterTeamId
		o.GuardId = m.GuardId
		o.Snap = m.Snap.Clone()
		o.LostBlood = m.LostBlood
		o.TeamType = m.TeamType
		return o
	}
	return nil
}

func InitLeagueBattleUser() *LeagueBattleUser {
	m := &LeagueBattleUser{}
	m.FixNilFields()
	return m
}
func (m *LeagueBattleUser) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *LeagueBattleBestUser) Clone() *LeagueBattleBestUser {
	if m != nil {
		o := &LeagueBattleBestUser{}
		o.Snap = m.Snap.Clone()
		o.Score = m.Score
		return o
	}
	return nil
}

func InitLeagueBattleBestUser() *LeagueBattleBestUser {
	m := &LeagueBattleBestUser{}
	m.FixNilFields()
	return m
}
func (m *LeagueBattleBestUser) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *LeagueBattleApplyUser) Clone() *LeagueBattleApplyUser {
	if m != nil {
		o := &LeagueBattleApplyUser{}
		o.Snap = m.Snap.Clone()
		o.TeamNums = m.TeamNums
		o.Applied = m.Applied
		return o
	}
	return nil
}

func InitLeagueBattleApplyUser() *LeagueBattleApplyUser {
	m := &LeagueBattleApplyUser{}
	m.FixNilFields()
	return m
}
func (m *LeagueBattleApplyUser) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *LeagueBattleRoom) Clone() *LeagueBattleRoom {
	if m != nil {
		o := &LeagueBattleRoom{}
		o.RoomId = m.RoomId
		o.TotalPower = m.TotalPower
		o.TotalGuardNum = m.TotalGuardNum
		o.AliveGuardNum = m.AliveGuardNum
		o.TotalMemberNum = m.TotalMemberNum
		o.AliveMemberNum = m.AliveMemberNum
		o.TotalEnergy = m.TotalEnergy
		o.CurrEnergy = m.CurrEnergy
		o.MainAttacker = m.MainAttacker.Clone()
		return o
	}
	return nil
}

func InitLeagueBattleRoom() *LeagueBattleRoom {
	m := &LeagueBattleRoom{}
	m.FixNilFields()
	return m
}
func (m *LeagueBattleRoom) FixNilFields() {
	if m != nil {

		if m.MainAttacker == nil {
			m.MainAttacker = &LeagueBattleBestUser{}
		}
		m.MainAttacker.FixNilFields()

	}
}
func (m *LeagueBattleLeague) Clone() *LeagueBattleLeague {
	if m != nil {
		o := &LeagueBattleLeague{}
		o.LeagueId = m.LeagueId
		o.Snap = m.Snap.Clone()
		o.ApplyNum = m.ApplyNum
		o.Rank = m.Rank
		o.Score = m.Score
		o.RoundStartRank = m.RoundStartRank
		o.RoundStartScore = m.RoundStartScore
		o.TotalEnergy = m.TotalEnergy
		o.CurrEnergy = m.CurrEnergy
		return o
	}
	return nil
}

func InitLeagueBattleLeague() *LeagueBattleLeague {
	m := &LeagueBattleLeague{}
	m.FixNilFields()
	return m
}
func (m *LeagueBattleLeague) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &LeagueSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *LeagueBattleBullet) Clone() *LeagueBattleBullet {
	if m != nil {
		o := &LeagueBattleBullet{}
		o.RoomId = m.RoomId
		o.Defeated = m.Defeated
		o.AttackerName = m.AttackerName
		o.EnemyLostEnergy = m.EnemyLostEnergy
		o.EnemyIsGuard = m.EnemyIsGuard
		o.EnemyName = m.EnemyName
		return o
	}
	return nil
}

func InitLeagueBattleBullet() *LeagueBattleBullet {
	m := &LeagueBattleBullet{}
	m.FixNilFields()
	return m
}
func (m *LeagueBattleBullet) FixNilFields() {
	if m != nil {

	}
}
func (m *LeagueBattleShopLevel) Clone() *LeagueBattleShopLevel {
	if m != nil {
		o := &LeagueBattleShopLevel{}
		o.Level = m.Level
		o.BuyCnt = m.BuyCnt
		if len(m.DailyBuyCnts) > 0 {
			o.DailyBuyCnts = make(map[uint32]uint32, len(m.DailyBuyCnts))
			for k, e := range m.DailyBuyCnts {
				o.DailyBuyCnts[k] = e
			}
		}
		if len(m.WeeklyBuyCnts) > 0 {
			o.WeeklyBuyCnts = make(map[uint32]uint32, len(m.WeeklyBuyCnts))
			for k, e := range m.WeeklyBuyCnts {
				o.WeeklyBuyCnts[k] = e
			}
		}
		if len(m.SeasonBuyCnts) > 0 {
			o.SeasonBuyCnts = make(map[uint32]uint32, len(m.SeasonBuyCnts))
			for k, e := range m.SeasonBuyCnts {
				o.SeasonBuyCnts[k] = e
			}
		}
		return o
	}
	return nil
}

func InitLeagueBattleShopLevel() *LeagueBattleShopLevel {
	m := &LeagueBattleShopLevel{}
	m.FixNilFields()
	return m
}
func (m *LeagueBattleShopLevel) FixNilFields() {
	if m != nil {

		if m.DailyBuyCnts == nil {
			m.DailyBuyCnts = make(map[uint32]uint32)
		}

		if m.WeeklyBuyCnts == nil {
			m.WeeklyBuyCnts = make(map[uint32]uint32)
		}

		if m.SeasonBuyCnts == nil {
			m.SeasonBuyCnts = make(map[uint32]uint32)
		}

	}
}
func (m *FirstCharge) Clone() *FirstCharge {
	if m != nil {
		o := &FirstCharge{}
		if len(m.Stages) > 0 {
			o.Stages = make([]*FirstChargeStage, len(m.Stages))
			for k, e := range m.Stages {
				o.Stages[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitFirstCharge() *FirstCharge {
	m := &FirstCharge{}
	m.FixNilFields()
	return m
}
func (m *FirstCharge) FixNilFields() {
	if m != nil {

		for _, itor := range m.Stages {
			itor.FixNilFields()
		}

	}
}
func (m *FirstChargeStage) Clone() *FirstChargeStage {
	if m != nil {
		o := &FirstChargeStage{}
		o.Id = m.Id
		o.ActivateTm = m.ActivateTm
		if len(m.Awards) > 0 {
			o.Awards = make([]uint32, len(m.Awards))
			copy(o.Awards, m.Awards)
		}
		return o
	}
	return nil
}

func InitFirstChargeStage() *FirstChargeStage {
	m := &FirstChargeStage{}
	m.FixNilFields()
	return m
}
func (m *FirstChargeStage) FixNilFields() {
	if m != nil {

	}
}
func (m *ClimbAwardInfo) Clone() *ClimbAwardInfo {
	if m != nil {
		o := &ClimbAwardInfo{}
		o.Id = m.Id
		o.ActivityId = m.ActivityId
		o.Floor = m.Floor
		o.Box = m.Box
		o.BoxProb = m.BoxProb
		o.AwardType = m.AwardType
		o.Options = m.Options
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.ExchangeTimes) > 0 {
			o.ExchangeTimes = make([]uint32, len(m.ExchangeTimes))
			copy(o.ExchangeTimes, m.ExchangeTimes)
		}
		if len(m.UnlockRounds) > 0 {
			o.UnlockRounds = make([]uint32, len(m.UnlockRounds))
			copy(o.UnlockRounds, m.UnlockRounds)
		}
		return o
	}
	return nil
}

func InitClimbAwardInfo() *ClimbAwardInfo {
	m := &ClimbAwardInfo{}
	m.FixNilFields()
	return m
}
func (m *ClimbAwardInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *ClimbCostInfo) Clone() *ClimbCostInfo {
	if m != nil {
		o := &ClimbCostInfo{}
		o.Id = m.Id
		o.ActivityId = m.ActivityId
		o.LowerLimit = m.LowerLimit
		o.UpperLimit = m.UpperLimit
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitClimbCostInfo() *ClimbCostInfo {
	m := &ClimbCostInfo{}
	m.FixNilFields()
	return m
}
func (m *ClimbCostInfo) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

	}
}
func (m *ClimbInfo) Clone() *ClimbInfo {
	if m != nil {
		o := &ClimbInfo{}
		o.Id = m.Id
		o.OpenLevel = m.OpenLevel
		o.ServerLimit = m.ServerLimit
		o.TimeType = m.TimeType
		o.OpenTime = m.OpenTime
		o.CloseTime = m.CloseTime
		o.PackageId = m.PackageId
		o.ShortDes = m.ShortDes
		o.LongDes = m.LongDes
		o.Round = m.Round
		o.PageId = m.PageId
		o.EntranceId = m.EntranceId
		o.ShowType_1 = m.ShowType_1
		o.ShowValue_1 = m.ShowValue_1
		o.ShowType_2 = m.ShowType_2
		o.ShowValue_2 = m.ShowValue_2
		o.ShowRound = m.ShowRound
		o.ShowType = m.ShowType
		o.ShowValue = m.ShowValue
		o.ShowSize = m.ShowSize
		return o
	}
	return nil
}

func InitClimbInfo() *ClimbInfo {
	m := &ClimbInfo{}
	m.FixNilFields()
	return m
}
func (m *ClimbInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *ClimbBox) Clone() *ClimbBox {
	if m != nil {
		o := &ClimbBox{}
		o.AwardId = m.AwardId
		o.SelectIndex = m.SelectIndex
		if len(m.RandNums) > 0 {
			o.RandNums = make(map[uint32]uint32, len(m.RandNums))
			for k, e := range m.RandNums {
				o.RandNums[k] = e
			}
		}
		o.TotalRandNum = m.TotalRandNum
		return o
	}
	return nil
}

func InitClimbBox() *ClimbBox {
	m := &ClimbBox{}
	m.FixNilFields()
	return m
}
func (m *ClimbBox) FixNilFields() {
	if m != nil {

		if m.RandNums == nil {
			m.RandNums = make(map[uint32]uint32)
		}

	}
}
func (m *Climb) Clone() *Climb {
	if m != nil {
		o := &Climb{}
		o.ActivityId = m.ActivityId
		o.Floor = m.Floor
		o.Round = m.Round
		o.TotalRandNum = m.TotalRandNum
		if len(m.Boxes) > 0 {
			o.Boxes = make(map[uint32]*ClimbBox, len(m.Boxes))
			for k, e := range m.Boxes {
				o.Boxes[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitClimb() *Climb {
	m := &Climb{}
	m.FixNilFields()
	return m
}
func (m *Climb) FixNilFields() {
	if m != nil {

		if m.Boxes == nil {
			m.Boxes = make(map[uint32]*ClimbBox)
		}
		for _, itor := range m.Boxes {
			itor.FixNilFields()
		}

	}
}
func (m *ClimbConfig) Clone() *ClimbConfig {
	if m != nil {
		o := &ClimbConfig{}
		if len(m.ServerVersion) > 0 {
			o.ServerVersion = make(map[uint32]uint32, len(m.ServerVersion))
			for k, e := range m.ServerVersion {
				o.ServerVersion[k] = e
			}
		}
		if len(m.AwardInfos) > 0 {
			o.AwardInfos = make([]*ClimbAwardInfo, len(m.AwardInfos))
			for k, e := range m.AwardInfos {
				o.AwardInfos[k] = e.Clone()
			}
		}
		if len(m.CostInfos) > 0 {
			o.CostInfos = make([]*ClimbCostInfo, len(m.CostInfos))
			for k, e := range m.CostInfos {
				o.CostInfos[k] = e.Clone()
			}
		}
		if len(m.Infos) > 0 {
			o.Infos = make([]*ClimbInfo, len(m.Infos))
			for k, e := range m.Infos {
				o.Infos[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitClimbConfig() *ClimbConfig {
	m := &ClimbConfig{}
	m.FixNilFields()
	return m
}
func (m *ClimbConfig) FixNilFields() {
	if m != nil {

		if m.ServerVersion == nil {
			m.ServerVersion = make(map[uint32]uint32)
		}

		for _, itor := range m.AwardInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.CostInfos {
			itor.FixNilFields()
		}

		for _, itor := range m.Infos {
			itor.FixNilFields()
		}

	}
}
func (m *AnotherWorldGuessInfo) Clone() *AnotherWorldGuessInfo {
	if m != nil {
		o := &AnotherWorldGuessInfo{}
		o.Guess = m.Guess.Clone()
		o.LeftTimes = m.LeftTimes
		o.RightTimes = m.RightTimes
		return o
	}
	return nil
}

func InitAnotherWorldGuessInfo() *AnotherWorldGuessInfo {
	m := &AnotherWorldGuessInfo{}
	m.FixNilFields()
	return m
}
func (m *AnotherWorldGuessInfo) FixNilFields() {
	if m != nil {

		if m.Guess == nil {
			m.Guess = &AnotherWorldGuess{}
		}
		m.Guess.FixNilFields()

	}
}
func (m *AnotherWorldGuess) Clone() *AnotherWorldGuess {
	if m != nil {
		o := &AnotherWorldGuess{}
		o.Index = m.Index
		o.Times = m.Times
		o.Flag = m.Flag
		return o
	}
	return nil
}

func InitAnotherWorldGuess() *AnotherWorldGuess {
	m := &AnotherWorldGuess{}
	m.FixNilFields()
	return m
}
func (m *AnotherWorldGuess) FixNilFields() {
	if m != nil {

	}
}
func (m *TeamFightHistory) Clone() *TeamFightHistory {
	if m != nil {
		o := &TeamFightHistory{}
		o.Credits = m.Credits
		o.WinRate = m.WinRate
		o.LocalRank = m.LocalRank
		o.CrossRank = m.CrossRank
		return o
	}
	return nil
}

func InitTeamFightHistory() *TeamFightHistory {
	m := &TeamFightHistory{}
	m.FixNilFields()
	return m
}
func (m *TeamFightHistory) FixNilFields() {
	if m != nil {

	}
}
func (m *TeamFightInfo) Clone() *TeamFightInfo {
	if m != nil {
		o := &TeamFightInfo{}
		o.EpochTime = m.EpochTime
		o.FightTimes = m.FightTimes
		o.WinTimes = m.WinTimes
		o.Credits = m.Credits
		o.LocalRank = m.LocalRank
		o.CrossRank = m.CrossRank
		o.MaxCredits = m.MaxCredits
		o.ActivePoints = m.ActivePoints
		o.Changes = m.Changes
		return o
	}
	return nil
}

func InitTeamFightInfo() *TeamFightInfo {
	m := &TeamFightInfo{}
	m.FixNilFields()
	return m
}
func (m *TeamFightInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *TeamFightTask) Clone() *TeamFightTask {
	if m != nil {
		o := &TeamFightTask{}
		o.ResetTime = m.ResetTime
		if len(m.Awarded) > 0 {
			o.Awarded = make([]uint32, len(m.Awarded))
			copy(o.Awarded, m.Awarded)
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitTeamFightTask() *TeamFightTask {
	m := &TeamFightTask{}
	m.FixNilFields()
	return m
}
func (m *TeamFightTask) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *TeamFightBriefVideo) Clone() *TeamFightBriefVideo {
	if m != nil {
		o := &TeamFightBriefVideo{}
		o.Id = m.Id
		o.Time = m.Time
		o.Win = m.Win
		o.AtkCredits = m.AtkCredits
		o.DefCredits = m.DefCredits
		o.Attacker = m.Attacker.Clone()
		o.Defender = m.Defender.Clone()
		o.DefenderRobotId = m.DefenderRobotId
		o.ShowValue = m.ShowValue
		return o
	}
	return nil
}

func InitTeamFightBriefVideo() *TeamFightBriefVideo {
	m := &TeamFightBriefVideo{}
	m.FixNilFields()
	return m
}
func (m *TeamFightBriefVideo) FixNilFields() {
	if m != nil {

		if m.Attacker == nil {
			m.Attacker = &UserSnapshot{}
		}
		m.Attacker.FixNilFields()

		if m.Defender == nil {
			m.Defender = &UserSnapshot{}
		}
		m.Defender.FixNilFields()

	}
}
func (m *ArchaicBranchNpc) Clone() *ArchaicBranchNpc {
	if m != nil {
		o := &ArchaicBranchNpc{}
		o.EventId = m.EventId
		o.Step = m.Step
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.AwardSteps) > 0 {
			o.AwardSteps = make([]uint32, len(m.AwardSteps))
			copy(o.AwardSteps, m.AwardSteps)
		}
		return o
	}
	return nil
}

func InitArchaicBranchNpc() *ArchaicBranchNpc {
	m := &ArchaicBranchNpc{}
	m.FixNilFields()
	return m
}
func (m *ArchaicBranchNpc) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *ArchaicMonster) Clone() *ArchaicMonster {
	if m != nil {
		o := &ArchaicMonster{}
		o.EventId = m.EventId
		if len(m.Difficulty) > 0 {
			o.Difficulty = make(map[uint32]*SmallKV, len(m.Difficulty))
			for k, e := range m.Difficulty {
				o.Difficulty[k] = e.Clone()
			}
		}
		o.BeatWin = m.BeatWin
		return o
	}
	return nil
}

func InitArchaicMonster() *ArchaicMonster {
	m := &ArchaicMonster{}
	m.FixNilFields()
	return m
}
func (m *ArchaicMonster) FixNilFields() {
	if m != nil {

		if m.Difficulty == nil {
			m.Difficulty = make(map[uint32]*SmallKV)
		}
		for _, itor := range m.Difficulty {
			itor.FixNilFields()
		}

	}
}
func (m *ArchaicBoss) Clone() *ArchaicBoss {
	if m != nil {
		o := &ArchaicBoss{}
		o.HarmAward = m.HarmAward.Clone()
		o.SeasonMaxHarm = m.SeasonMaxHarm
		return o
	}
	return nil
}

func InitArchaicBoss() *ArchaicBoss {
	m := &ArchaicBoss{}
	m.FixNilFields()
	return m
}
func (m *ArchaicBoss) FixNilFields() {
	if m != nil {

		if m.HarmAward == nil {
			m.HarmAward = &ReceivedAward{}
		}
		m.HarmAward.FixNilFields()

	}
}
func (m *ArchaicSkillGrid) Clone() *ArchaicSkillGrid {
	if m != nil {
		o := &ArchaicSkillGrid{}
		o.Index = m.Index
		o.SeasonSkillId = m.SeasonSkillId
		return o
	}
	return nil
}

func InitArchaicSkillGrid() *ArchaicSkillGrid {
	m := &ArchaicSkillGrid{}
	m.FixNilFields()
	return m
}
func (m *ArchaicSkillGrid) FixNilFields() {
	if m != nil {

	}
}
func (m *ArchaicFormationTeam) Clone() *ArchaicFormationTeam {
	if m != nil {
		o := &ArchaicFormationTeam{}
		o.TeamId = m.TeamId
		o.Unlock = m.Unlock
		o.Strength = m.Strength
		o.DailyBossMaxHarm = m.DailyBossMaxHarm
		if len(m.SkillGrids) > 0 {
			o.SkillGrids = make([]*ArchaicSkillGrid, len(m.SkillGrids))
			for k, e := range m.SkillGrids {
				o.SkillGrids[k] = e.Clone()
			}
		}
		if len(m.LockSkillGroups) > 0 {
			o.LockSkillGroups = make([]uint32, len(m.LockSkillGroups))
			copy(o.LockSkillGroups, m.LockSkillGroups)
		}
		return o
	}
	return nil
}

func InitArchaicFormationTeam() *ArchaicFormationTeam {
	m := &ArchaicFormationTeam{}
	m.FixNilFields()
	return m
}
func (m *ArchaicFormationTeam) FixNilFields() {
	if m != nil {

		for _, itor := range m.SkillGrids {
			itor.FixNilFields()
		}

	}
}
func (m *Archaic) Clone() *Archaic {
	if m != nil {
		o := &Archaic{}
		o.Id = m.Id
		o.DailyTime = m.DailyTime
		o.Season = m.Season
		o.ChapterId = m.ChapterId
		if len(m.Npcs) > 0 {
			o.Npcs = make(map[uint32]*ArchaicBranchNpc, len(m.Npcs))
			for k, e := range m.Npcs {
				o.Npcs[k] = e.Clone()
			}
		}
		if len(m.Monsters) > 0 {
			o.Monsters = make(map[uint32]*ArchaicMonster, len(m.Monsters))
			for k, e := range m.Monsters {
				o.Monsters[k] = e.Clone()
			}
		}
		o.Boss = m.Boss.Clone()
		o.Level = m.Level
		o.Exp = m.Exp
		o.LevelAward = m.LevelAward.Clone()
		if len(m.Skills) > 0 {
			o.Skills = make(map[uint32]uint32, len(m.Skills))
			for k, e := range m.Skills {
				o.Skills[k] = e
			}
		}
		if len(m.Teams) > 0 {
			o.Teams = make([]*ArchaicFormationTeam, len(m.Teams))
			for k, e := range m.Teams {
				o.Teams[k] = e.Clone()
			}
		}
		o.LevelMailAward = m.LevelMailAward
		return o
	}
	return nil
}

func InitArchaic() *Archaic {
	m := &Archaic{}
	m.FixNilFields()
	return m
}
func (m *Archaic) FixNilFields() {
	if m != nil {

		if m.Npcs == nil {
			m.Npcs = make(map[uint32]*ArchaicBranchNpc)
		}
		for _, itor := range m.Npcs {
			itor.FixNilFields()
		}

		if m.Monsters == nil {
			m.Monsters = make(map[uint32]*ArchaicMonster)
		}
		for _, itor := range m.Monsters {
			itor.FixNilFields()
		}

		if m.Boss == nil {
			m.Boss = &ArchaicBoss{}
		}
		m.Boss.FixNilFields()

		if m.LevelAward == nil {
			m.LevelAward = &ReceivedAward{}
		}
		m.LevelAward.FixNilFields()

		if m.Skills == nil {
			m.Skills = make(map[uint32]uint32)
		}

		for _, itor := range m.Teams {
			itor.FixNilFields()
		}

	}
}
func (m *ArchaicLevelTopOne) Clone() *ArchaicLevelTopOne {
	if m != nil {
		o := &ArchaicLevelTopOne{}
		o.Base = m.Base.Clone()
		o.LeagueName = m.LeagueName
		return o
	}
	return nil
}

func InitArchaicLevelTopOne() *ArchaicLevelTopOne {
	m := &ArchaicLevelTopOne{}
	m.FixNilFields()
	return m
}
func (m *ArchaicLevelTopOne) FixNilFields() {
	if m != nil {

		if m.Base == nil {
			m.Base = &PairU32{}
		}
		m.Base.FixNilFields()

	}
}
func (m *DeicideTower) Clone() *DeicideTower {
	if m != nil {
		o := &DeicideTower{}
		o.Stage = m.Stage
		if len(m.FirstClear) > 0 {
			o.FirstClear = make(map[uint32]uint32, len(m.FirstClear))
			for k, e := range m.FirstClear {
				o.FirstClear[k] = e
			}
		}
		return o
	}
	return nil
}

func InitDeicideTower() *DeicideTower {
	m := &DeicideTower{}
	m.FixNilFields()
	return m
}
func (m *DeicideTower) FixNilFields() {
	if m != nil {

		if m.FirstClear == nil {
			m.FirstClear = make(map[uint32]uint32)
		}

	}
}
func (m *Principle) Clone() *Principle {
	if m != nil {
		o := &Principle{}
		o.Id = m.Id
		o.Level = m.Level
		o.ProbAdd = m.ProbAdd
		o.ThunderCd = m.ThunderCd
		if len(m.AwardIds) > 0 {
			o.AwardIds = make([]uint32, len(m.AwardIds))
			copy(o.AwardIds, m.AwardIds)
		}
		return o
	}
	return nil
}

func InitPrinciple() *Principle {
	m := &Principle{}
	m.FixNilFields()
	return m
}
func (m *Principle) FixNilFields() {
	if m != nil {

	}
}
func (m *PrincipleCrossThunder) Clone() *PrincipleCrossThunder {
	if m != nil {
		o := &PrincipleCrossThunder{}
		o.Id = m.Id
		o.Hp = m.Hp
		o.Times = m.Times
		o.PillUsed = m.PillUsed
		if len(m.Knights) > 0 {
			o.Knights = make([]uint32, len(m.Knights))
			copy(o.Knights, m.Knights)
		}
		return o
	}
	return nil
}

func InitPrincipleCrossThunder() *PrincipleCrossThunder {
	m := &PrincipleCrossThunder{}
	m.FixNilFields()
	return m
}
func (m *PrincipleCrossThunder) FixNilFields() {
	if m != nil {

	}
}
func (m *PrinciplePracticeGroup) Clone() *PrinciplePracticeGroup {
	if m != nil {
		o := &PrinciplePracticeGroup{}
		o.Group = m.Group
		o.Level = m.Level
		o.Pid = m.Pid
		o.Kid = m.Kid
		return o
	}
	return nil
}

func InitPrinciplePracticeGroup() *PrinciplePracticeGroup {
	m := &PrinciplePracticeGroup{}
	m.FixNilFields()
	return m
}
func (m *PrinciplePracticeGroup) FixNilFields() {
	if m != nil {

	}
}
func (m *PrinciplePractice) Clone() *PrinciplePractice {
	if m != nil {
		o := &PrinciplePractice{}
		o.StartTime = m.StartTime
		o.FixedTime = m.FixedTime
		o.RandTime = m.RandTime
		if len(m.Exps) > 0 {
			o.Exps = make(map[uint32]uint64, len(m.Exps))
			for k, e := range m.Exps {
				o.Exps[k] = e
			}
		}
		if len(m.Groups) > 0 {
			o.Groups = make([]*PrinciplePracticeGroup, len(m.Groups))
			for k, e := range m.Groups {
				o.Groups[k] = e.Clone()
			}
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		if len(m.ReceivedAwards) > 0 {
			o.ReceivedAwards = make(map[uint32]*ReceivedAward, len(m.ReceivedAwards))
			for k, e := range m.ReceivedAwards {
				o.ReceivedAwards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitPrinciplePractice() *PrinciplePractice {
	m := &PrinciplePractice{}
	m.FixNilFields()
	return m
}
func (m *PrinciplePractice) FixNilFields() {
	if m != nil {

		if m.Exps == nil {
			m.Exps = make(map[uint32]uint64)
		}

		for _, itor := range m.Groups {
			itor.FixNilFields()
		}

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

		if m.ReceivedAwards == nil {
			m.ReceivedAwards = make(map[uint32]*ReceivedAward)
		}
		for _, itor := range m.ReceivedAwards {
			itor.FixNilFields()
		}

	}
}
func (m *DigestionCost) Clone() *DigestionCost {
	if m != nil {
		o := &DigestionCost{}
		o.ResType = m.ResType
		o.ResValue = m.ResValue
		o.CostCnt = m.CostCnt
		return o
	}
	return nil
}

func InitDigestionCost() *DigestionCost {
	m := &DigestionCost{}
	m.FixNilFields()
	return m
}
func (m *DigestionCost) FixNilFields() {
	if m != nil {

	}
}
func (m *DigestionGroup) Clone() *DigestionGroup {
	if m != nil {
		o := &DigestionGroup{}
		o.Id = m.Id
		o.Level = m.Level
		if len(m.Costs) > 0 {
			o.Costs = make([]*DigestionCost, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitDigestionGroup() *DigestionGroup {
	m := &DigestionGroup{}
	m.FixNilFields()
	return m
}
func (m *DigestionGroup) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

	}
}
func (m *Digestion) Clone() *Digestion {
	if m != nil {
		o := &Digestion{}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.Groups) > 0 {
			o.Groups = make(map[uint32]*DigestionGroup, len(m.Groups))
			for k, e := range m.Groups {
				o.Groups[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitDigestion() *Digestion {
	m := &Digestion{}
	m.FixNilFields()
	return m
}
func (m *Digestion) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

		if m.Groups == nil {
			m.Groups = make(map[uint32]*DigestionGroup)
		}
		for _, itor := range m.Groups {
			itor.FixNilFields()
		}

	}
}
func (m *KnightGradeCell) Clone() *KnightGradeCell {
	if m != nil {
		o := &KnightGradeCell{}
		o.Cell = m.Cell
		o.KnightId = m.KnightId
		o.Grade = m.Grade
		o.DownTime = m.DownTime
		if len(m.Costs) > 0 {
			o.Costs = make([]*Resource, len(m.Costs))
			for k, e := range m.Costs {
				o.Costs[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitKnightGradeCell() *KnightGradeCell {
	m := &KnightGradeCell{}
	m.FixNilFields()
	return m
}
func (m *KnightGradeCell) FixNilFields() {
	if m != nil {

		for _, itor := range m.Costs {
			itor.FixNilFields()
		}

	}
}
func (m *KnightGrade) Clone() *KnightGrade {
	if m != nil {
		o := &KnightGrade{}
		if len(m.Cells) > 0 {
			o.Cells = make(map[uint32]*KnightGradeCell, len(m.Cells))
			for k, e := range m.Cells {
				o.Cells[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitKnightGrade() *KnightGrade {
	m := &KnightGrade{}
	m.FixNilFields()
	return m
}
func (m *KnightGrade) FixNilFields() {
	if m != nil {

		if m.Cells == nil {
			m.Cells = make(map[uint32]*KnightGradeCell)
		}
		for _, itor := range m.Cells {
			itor.FixNilFields()
		}

	}
}
func (m *AssistantExtraData) Clone() *AssistantExtraData {
	if m != nil {
		o := &AssistantExtraData{}
		o.RelicsChapterId = m.RelicsChapterId
		return o
	}
	return nil
}

func InitAssistantExtraData() *AssistantExtraData {
	m := &AssistantExtraData{}
	m.FixNilFields()
	return m
}
func (m *AssistantExtraData) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarMoving) Clone() *StarWarMoving {
	if m != nil {
		o := &StarWarMoving{}
		o.From = m.From.Clone()
		o.To = m.To.Clone()
		o.StartTime = m.StartTime
		o.EndTime = m.EndTime
		if len(m.Portals) > 0 {
			o.Portals = make([]*Coordinate, len(m.Portals))
			for k, e := range m.Portals {
				o.Portals[k] = e.Clone()
			}
		}
		o.ToAreaId = m.ToAreaId
		o.IsBacking = m.IsBacking
		if len(m.Corners1) > 0 {
			o.Corners1 = make([]*Coordinate, len(m.Corners1))
			for k, e := range m.Corners1 {
				o.Corners1[k] = e.Clone()
			}
		}
		if len(m.Corners2) > 0 {
			o.Corners2 = make([]*Coordinate, len(m.Corners2))
			for k, e := range m.Corners2 {
				o.Corners2[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitStarWarMoving() *StarWarMoving {
	m := &StarWarMoving{}
	m.FixNilFields()
	return m
}
func (m *StarWarMoving) FixNilFields() {
	if m != nil {

		if m.From == nil {
			m.From = &Coordinate{}
		}
		m.From.FixNilFields()

		if m.To == nil {
			m.To = &Coordinate{}
		}
		m.To.FixNilFields()

		for _, itor := range m.Portals {
			itor.FixNilFields()
		}

		for _, itor := range m.Corners1 {
			itor.FixNilFields()
		}

		for _, itor := range m.Corners2 {
			itor.FixNilFields()
		}

	}
}
func (m *StarWarTeamSimpleSnap) Clone() *StarWarTeamSimpleSnap {
	if m != nil {
		o := &StarWarTeamSimpleSnap{}
		o.Sid = m.Sid
		o.Name = m.Name
		o.BaseId = m.BaseId
		o.MountId = m.MountId
		o.FashionId = m.FashionId
		return o
	}
	return nil
}

func InitStarWarTeamSimpleSnap() *StarWarTeamSimpleSnap {
	m := &StarWarTeamSimpleSnap{}
	m.FixNilFields()
	return m
}
func (m *StarWarTeamSimpleSnap) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarSimpleTeam) Clone() *StarWarSimpleTeam {
	if m != nil {
		o := &StarWarSimpleTeam{}
		o.UserId = m.UserId
		o.Union = m.Union
		o.Type = m.Type
		o.Moving = m.Moving.Clone()
		o.Snap = m.Snap.Clone()
		return o
	}
	return nil
}

func InitStarWarSimpleTeam() *StarWarSimpleTeam {
	m := &StarWarSimpleTeam{}
	m.FixNilFields()
	return m
}
func (m *StarWarSimpleTeam) FixNilFields() {
	if m != nil {

		if m.Moving == nil {
			m.Moving = &StarWarMoving{}
		}
		m.Moving.FixNilFields()

		if m.Snap == nil {
			m.Snap = &StarWarTeamSimpleSnap{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *StarWarTeamHeadSnap) Clone() *StarWarTeamHeadSnap {
	if m != nil {
		o := &StarWarTeamHeadSnap{}
		o.ServerId = m.ServerId
		o.Power = m.Power
		o.Name = m.Name
		o.BaseId = m.BaseId
		o.FashionId = m.FashionId
		if len(m.Appearances) > 0 {
			o.Appearances = make([]uint32, len(m.Appearances))
			copy(o.Appearances, m.Appearances)
		}
		o.Id = m.Id
		return o
	}
	return nil
}

func InitStarWarTeamHeadSnap() *StarWarTeamHeadSnap {
	m := &StarWarTeamHeadSnap{}
	m.FixNilFields()
	return m
}
func (m *StarWarTeamHeadSnap) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarDetailTeam) Clone() *StarWarDetailTeam {
	if m != nil {
		o := &StarWarDetailTeam{}
		o.UserId = m.UserId
		o.Union = m.Union
		o.Type = m.Type
		o.Career = m.Career
		o.Energy = m.Energy
		o.Snap = m.Snap.Clone()
		return o
	}
	return nil
}

func InitStarWarDetailTeam() *StarWarDetailTeam {
	m := &StarWarDetailTeam{}
	m.FixNilFields()
	return m
}
func (m *StarWarDetailTeam) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &StarWarTeamHeadSnap{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *StarWarMyTeam) Clone() *StarWarMyTeam {
	if m != nil {
		o := &StarWarMyTeam{}
		o.Type = m.Type
		o.Energy = m.Energy
		o.Strength = m.Strength
		o.KillCnt = m.KillCnt
		o.StateEndTime = m.StateEndTime
		o.State = m.State
		o.Pos = m.Pos.Clone()
		o.Moving = m.Moving.Clone()
		o.DailyBuyedStrength = m.DailyBuyedStrength
		o.DailyBuyedEnergy = m.DailyBuyedEnergy
		return o
	}
	return nil
}

func InitStarWarMyTeam() *StarWarMyTeam {
	m := &StarWarMyTeam{}
	m.FixNilFields()
	return m
}
func (m *StarWarMyTeam) FixNilFields() {
	if m != nil {

		if m.Pos == nil {
			m.Pos = &Coordinate{}
		}
		m.Pos.FixNilFields()

		if m.Moving == nil {
			m.Moving = &StarWarMoving{}
		}
		m.Moving.FixNilFields()

	}
}
func (m *StarWarUserData) Clone() *StarWarUserData {
	if m != nil {
		o := &StarWarUserData{}
		o.Uid = m.Uid
		o.Career = m.Career
		o.Union = m.Union
		if len(m.Territorys) > 0 {
			o.Territorys = make([]*Coordinate, len(m.Territorys))
			for k, e := range m.Territorys {
				o.Territorys[k] = e.Clone()
			}
		}
		o.CityEventId = m.CityEventId
		o.CityAppoint = m.CityAppoint
		if len(m.AgentCityEventIds) > 0 {
			o.AgentCityEventIds = make([]uint32, len(m.AgentCityEventIds))
			copy(o.AgentCityEventIds, m.AgentCityEventIds)
		}
		if len(m.Teams) > 0 {
			o.Teams = make([]*StarWarMyTeam, len(m.Teams))
			for k, e := range m.Teams {
				o.Teams[k] = e.Clone()
			}
		}
		o.SelectAgentCity = m.SelectAgentCity
		o.DropStartTime = m.DropStartTime
		o.DailyResetTime = m.DailyResetTime
		if len(m.TaskProgress) > 0 {
			o.TaskProgress = make(map[uint32]uint32, len(m.TaskProgress))
			for k, e := range m.TaskProgress {
				o.TaskProgress[k] = e
			}
		}
		if len(m.TaskAwards) > 0 {
			o.TaskAwards = make([]uint32, len(m.TaskAwards))
			copy(o.TaskAwards, m.TaskAwards)
		}
		return o
	}
	return nil
}

func InitStarWarUserData() *StarWarUserData {
	m := &StarWarUserData{}
	m.FixNilFields()
	return m
}
func (m *StarWarUserData) FixNilFields() {
	if m != nil {

		for _, itor := range m.Territorys {
			itor.FixNilFields()
		}

		for _, itor := range m.Teams {
			itor.FixNilFields()
		}

		if m.TaskProgress == nil {
			m.TaskProgress = make(map[uint32]uint32)
		}

	}
}
func (m *StarWarSimpleCity) Clone() *StarWarSimpleCity {
	if m != nil {
		o := &StarWarSimpleCity{}
		o.Pos = m.Pos.Clone()
		o.OwnerUser = m.OwnerUser
		o.OwnerIsAgent = m.OwnerIsAgent
		o.OwnerUnion = m.OwnerUnion
		o.CityEventId = m.CityEventId
		o.IsBattling = m.IsBattling
		return o
	}
	return nil
}

func InitStarWarSimpleCity() *StarWarSimpleCity {
	m := &StarWarSimpleCity{}
	m.FixNilFields()
	return m
}
func (m *StarWarSimpleCity) FixNilFields() {
	if m != nil {

		if m.Pos == nil {
			m.Pos = &Coordinate{}
		}
		m.Pos.FixNilFields()

	}
}
func (m *StarWarDetailCity) Clone() *StarWarDetailCity {
	if m != nil {
		o := &StarWarDetailCity{}
		o.Simple = m.Simple.Clone()
		o.Defense = m.Defense
		o.OwnerMainSnap = m.OwnerMainSnap.Clone()
		if len(m.Buffs) > 0 {
			o.Buffs = make([]uint32, len(m.Buffs))
			copy(o.Buffs, m.Buffs)
		}
		if len(m.ValidTerritorysByLevel) > 0 {
			o.ValidTerritorysByLevel = make(map[uint32]uint32, len(m.ValidTerritorysByLevel))
			for k, e := range m.ValidTerritorysByLevel {
				o.ValidTerritorysByLevel[k] = e
			}
		}
		o.JobUserNum = m.JobUserNum
		return o
	}
	return nil
}

func InitStarWarDetailCity() *StarWarDetailCity {
	m := &StarWarDetailCity{}
	m.FixNilFields()
	return m
}
func (m *StarWarDetailCity) FixNilFields() {
	if m != nil {

		if m.Simple == nil {
			m.Simple = &StarWarSimpleCity{}
		}
		m.Simple.FixNilFields()

		if m.OwnerMainSnap == nil {
			m.OwnerMainSnap = &UserSnapshot{}
		}
		m.OwnerMainSnap.FixNilFields()

		if m.ValidTerritorysByLevel == nil {
			m.ValidTerritorysByLevel = make(map[uint32]uint32)
		}

	}
}
func (m *StarWarSimpleTerritory) Clone() *StarWarSimpleTerritory {
	if m != nil {
		o := &StarWarSimpleTerritory{}
		o.Pos = m.Pos.Clone()
		o.OwnerUser = m.OwnerUser
		o.OwnerUnion = m.OwnerUnion
		o.IsBattling = m.IsBattling
		return o
	}
	return nil
}

func InitStarWarSimpleTerritory() *StarWarSimpleTerritory {
	m := &StarWarSimpleTerritory{}
	m.FixNilFields()
	return m
}
func (m *StarWarSimpleTerritory) FixNilFields() {
	if m != nil {

		if m.Pos == nil {
			m.Pos = &Coordinate{}
		}
		m.Pos.FixNilFields()

	}
}
func (m *StarWarDetailTerritory) Clone() *StarWarDetailTerritory {
	if m != nil {
		o := &StarWarDetailTerritory{}
		o.Simple = m.Simple.Clone()
		o.Defense = m.Defense
		o.OwnerSnap = m.OwnerSnap.Clone()
		return o
	}
	return nil
}

func InitStarWarDetailTerritory() *StarWarDetailTerritory {
	m := &StarWarDetailTerritory{}
	m.FixNilFields()
	return m
}
func (m *StarWarDetailTerritory) FixNilFields() {
	if m != nil {

		if m.Simple == nil {
			m.Simple = &StarWarSimpleTerritory{}
		}
		m.Simple.FixNilFields()

		if m.OwnerSnap == nil {
			m.OwnerSnap = &StarWarTeamHeadSnap{}
		}
		m.OwnerSnap.FixNilFields()

	}
}
func (m *StarWarMoveParam) Clone() *StarWarMoveParam {
	if m != nil {
		o := &StarWarMoveParam{}
		o.TeamType = m.TeamType
		o.CostStrength = m.CostStrength
		if len(m.Coors) > 0 {
			o.Coors = make([]*Coordinate, len(m.Coors))
			for k, e := range m.Coors {
				o.Coors[k] = e.Clone()
			}
		}
		if len(m.Portals) > 0 {
			o.Portals = make([]*Coordinate, len(m.Portals))
			for k, e := range m.Portals {
				o.Portals[k] = e.Clone()
			}
		}
		if len(m.Corners1) > 0 {
			o.Corners1 = make([]*Coordinate, len(m.Corners1))
			for k, e := range m.Corners1 {
				o.Corners1[k] = e.Clone()
			}
		}
		if len(m.Corners2) > 0 {
			o.Corners2 = make([]*Coordinate, len(m.Corners2))
			for k, e := range m.Corners2 {
				o.Corners2[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitStarWarMoveParam() *StarWarMoveParam {
	m := &StarWarMoveParam{}
	m.FixNilFields()
	return m
}
func (m *StarWarMoveParam) FixNilFields() {
	if m != nil {

		for _, itor := range m.Coors {
			itor.FixNilFields()
		}

		for _, itor := range m.Portals {
			itor.FixNilFields()
		}

		for _, itor := range m.Corners1 {
			itor.FixNilFields()
		}

		for _, itor := range m.Corners2 {
			itor.FixNilFields()
		}

	}
}
func (m *StarWarMoveResult) Clone() *StarWarMoveResult {
	if m != nil {
		o := &StarWarMoveResult{}
		o.TeamType = m.TeamType
		o.CostStrength = m.CostStrength
		o.Moving = m.Moving.Clone()
		return o
	}
	return nil
}

func InitStarWarMoveResult() *StarWarMoveResult {
	m := &StarWarMoveResult{}
	m.FixNilFields()
	return m
}
func (m *StarWarMoveResult) FixNilFields() {
	if m != nil {

		if m.Moving == nil {
			m.Moving = &StarWarMoving{}
		}
		m.Moving.FixNilFields()

	}
}
func (m *StarWarUnionRank) Clone() *StarWarUnionRank {
	if m != nil {
		o := &StarWarUnionRank{}
		o.Id = m.Id
		o.TotalScore = m.TotalScore
		o.TotalPower = m.TotalPower
		return o
	}
	return nil
}

func InitStarWarUnionRank() *StarWarUnionRank {
	m := &StarWarUnionRank{}
	m.FixNilFields()
	return m
}
func (m *StarWarUnionRank) FixNilFields() {
	if m != nil {

	}
}
func (m *CityMember) Clone() *CityMember {
	if m != nil {
		o := &CityMember{}
		o.Uid = m.Uid
		o.Career = m.Career
		o.CityEventId = m.CityEventId
		o.Appoint = m.Appoint
		o.ValidTerritoryLevels = m.ValidTerritoryLevels
		return o
	}
	return nil
}

func InitCityMember() *CityMember {
	m := &CityMember{}
	m.FixNilFields()
	return m
}
func (m *CityMember) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarCityState) Clone() *StarWarCityState {
	if m != nil {
		o := &StarWarCityState{}
		o.CityEventId = m.CityEventId
		o.UnionId = m.UnionId
		o.OwnerUserName = m.OwnerUserName
		o.IsBattling = m.IsBattling
		o.JobUserNum = m.JobUserNum
		o.StageBackedUnionId = m.StageBackedUnionId
		return o
	}
	return nil
}

func InitStarWarCityState() *StarWarCityState {
	m := &StarWarCityState{}
	m.FixNilFields()
	return m
}
func (m *StarWarCityState) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarCityDropSkillAddition) Clone() *StarWarCityDropSkillAddition {
	if m != nil {
		o := &StarWarCityDropSkillAddition{}
		o.UserName = m.UserName
		o.SkillId = m.SkillId
		o.Addition = m.Addition
		return o
	}
	return nil
}

func InitStarWarCityDropSkillAddition() *StarWarCityDropSkillAddition {
	m := &StarWarCityDropSkillAddition{}
	m.FixNilFields()
	return m
}
func (m *StarWarCityDropSkillAddition) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarBattleLog) Clone() *StarWarBattleLog {
	if m != nil {
		o := &StarWarBattleLog{}
		o.Attacker = m.Attacker.Clone()
		o.AttackerTeamType = m.AttackerTeamType
		o.AttackerSubEnergy = m.AttackerSubEnergy
		o.AttackerLeftEnergy = m.AttackerLeftEnergy
		o.AttackerMaxEnergy = m.AttackerMaxEnergy
		o.AttackerUnion = m.AttackerUnion
		o.AttackerWin = m.AttackerWin
		o.Pos = m.Pos.Clone()
		o.Time = m.Time
		o.DefenderUnion = m.DefenderUnion
		o.DefenderMonster = m.DefenderMonster
		o.MonsterSubDefense = m.MonsterSubDefense
		o.MonsterLeftDefense = m.MonsterLeftDefense
		o.MonsterMaxDefense = m.MonsterMaxDefense
		o.Defender = m.Defender.Clone()
		o.DefenderTeamType = m.DefenderTeamType
		o.DefenderSubEnergy = m.DefenderSubEnergy
		o.DefenderLeftEnergy = m.DefenderLeftEnergy
		o.DefenderMaxEnergy = m.DefenderMaxEnergy
		return o
	}
	return nil
}

func InitStarWarBattleLog() *StarWarBattleLog {
	m := &StarWarBattleLog{}
	m.FixNilFields()
	return m
}
func (m *StarWarBattleLog) FixNilFields() {
	if m != nil {

		if m.Attacker == nil {
			m.Attacker = &StarWarTeamHeadSnap{}
		}
		m.Attacker.FixNilFields()

		if m.Pos == nil {
			m.Pos = &Coordinate{}
		}
		m.Pos.FixNilFields()

		if m.Defender == nil {
			m.Defender = &StarWarTeamHeadSnap{}
		}
		m.Defender.FixNilFields()

	}
}
func (m *StarWarServers) Clone() *StarWarServers {
	if m != nil {
		o := &StarWarServers{}
		o.SubId = m.SubId
		if len(m.ServerIds) > 0 {
			o.ServerIds = make([]uint64, len(m.ServerIds))
			copy(o.ServerIds, m.ServerIds)
		}
		o.PartId = m.PartId
		return o
	}
	return nil
}

func InitStarWarServers() *StarWarServers {
	m := &StarWarServers{}
	m.FixNilFields()
	return m
}
func (m *StarWarServers) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarTerritoryLog) Clone() *StarWarTerritoryLog {
	if m != nil {
		o := &StarWarTerritoryLog{}
		o.Pos = m.Pos.Clone()
		o.Time = m.Time
		o.Lost = m.Lost
		o.OwnerUser = m.OwnerUser
		o.OwnerUnion = m.OwnerUnion
		o.OwnerPower = m.OwnerPower
		o.OwnerSid = m.OwnerSid
		return o
	}
	return nil
}

func InitStarWarTerritoryLog() *StarWarTerritoryLog {
	m := &StarWarTerritoryLog{}
	m.FixNilFields()
	return m
}
func (m *StarWarTerritoryLog) FixNilFields() {
	if m != nil {

		if m.Pos == nil {
			m.Pos = &Coordinate{}
		}
		m.Pos.FixNilFields()

	}
}
func (m *StarWarCareer) Clone() *StarWarCareer {
	if m != nil {
		o := &StarWarCareer{}
		o.Id = m.Id
		o.Times = m.Times
		if len(m.Skills) > 0 {
			o.Skills = make(map[uint32]*StarWarSkill, len(m.Skills))
			for k, e := range m.Skills {
				o.Skills[k] = e.Clone()
			}
		}
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*StarWarCondition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		o.SkillActive = m.SkillActive
		if len(m.UnlockedCareers) > 0 {
			o.UnlockedCareers = make([]uint32, len(m.UnlockedCareers))
			copy(o.UnlockedCareers, m.UnlockedCareers)
		}
		o.UsedSkillPoint = m.UsedSkillPoint
		return o
	}
	return nil
}

func InitStarWarCareer() *StarWarCareer {
	m := &StarWarCareer{}
	m.FixNilFields()
	return m
}
func (m *StarWarCareer) FixNilFields() {
	if m != nil {

		if m.Skills == nil {
			m.Skills = make(map[uint32]*StarWarSkill)
		}
		for _, itor := range m.Skills {
			itor.FixNilFields()
		}

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*StarWarCondition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *StarWarCondition) Clone() *StarWarCondition {
	if m != nil {
		o := &StarWarCondition{}
		o.Id = m.Id
		o.Progress = m.Progress
		return o
	}
	return nil
}

func InitStarWarCondition() *StarWarCondition {
	m := &StarWarCondition{}
	m.FixNilFields()
	return m
}
func (m *StarWarCondition) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarSkill) Clone() *StarWarSkill {
	if m != nil {
		o := &StarWarSkill{}
		o.Id = m.Id
		o.Limit1 = m.Limit1
		o.Limit2 = m.Limit2
		o.Limit3 = m.Limit3
		return o
	}
	return nil
}

func InitStarWarSkill() *StarWarSkill {
	m := &StarWarSkill{}
	m.FixNilFields()
	return m
}
func (m *StarWarSkill) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarUnion) Clone() *StarWarUnion {
	if m != nil {
		o := &StarWarUnion{}
		o.Id = m.Id
		o.MemberCount = m.MemberCount
		o.PowerScore = m.PowerScore
		return o
	}
	return nil
}

func InitStarWarUnion() *StarWarUnion {
	m := &StarWarUnion{}
	m.FixNilFields()
	return m
}
func (m *StarWarUnion) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarUnionMember) Clone() *StarWarUnionMember {
	if m != nil {
		o := &StarWarUnionMember{}
		o.User = m.User.Clone()
		o.CityId = m.CityId
		o.IsCityOwner = m.IsCityOwner
		return o
	}
	return nil
}

func InitStarWarUnionMember() *StarWarUnionMember {
	m := &StarWarUnionMember{}
	m.FixNilFields()
	return m
}
func (m *StarWarUnionMember) FixNilFields() {
	if m != nil {

		if m.User == nil {
			m.User = &UserSnapshot{}
		}
		m.User.FixNilFields()

	}
}
func (m *StarWarShopGoodsRecord) Clone() *StarWarShopGoodsRecord {
	if m != nil {
		o := &StarWarShopGoodsRecord{}
		o.BuyTime = m.BuyTime
		o.BuyCount = m.BuyCount
		return o
	}
	return nil
}

func InitStarWarShopGoodsRecord() *StarWarShopGoodsRecord {
	m := &StarWarShopGoodsRecord{}
	m.FixNilFields()
	return m
}
func (m *StarWarShopGoodsRecord) FixNilFields() {
	if m != nil {

	}
}
func (m *StarWarShopBuyRecord) Clone() *StarWarShopBuyRecord {
	if m != nil {
		o := &StarWarShopBuyRecord{}
		if len(m.BuyRecord) > 0 {
			o.BuyRecord = make(map[uint32]*StarWarShopGoodsRecord, len(m.BuyRecord))
			for k, e := range m.BuyRecord {
				o.BuyRecord[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitStarWarShopBuyRecord() *StarWarShopBuyRecord {
	m := &StarWarShopBuyRecord{}
	m.FixNilFields()
	return m
}
func (m *StarWarShopBuyRecord) FixNilFields() {
	if m != nil {

		if m.BuyRecord == nil {
			m.BuyRecord = make(map[uint32]*StarWarShopGoodsRecord)
		}
		for _, itor := range m.BuyRecord {
			itor.FixNilFields()
		}

	}
}
func (m *StarWarMessages) Clone() *StarWarMessages {
	if m != nil {
		o := &StarWarMessages{}
		if len(m.Datas) > 0 {
			o.Datas = make([]*StarWarMessage, len(m.Datas))
			for k, e := range m.Datas {
				o.Datas[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitStarWarMessages() *StarWarMessages {
	m := &StarWarMessages{}
	m.FixNilFields()
	return m
}
func (m *StarWarMessages) FixNilFields() {
	if m != nil {

		for _, itor := range m.Datas {
			itor.FixNilFields()
		}

	}
}
func (m *StarWarMessage) Clone() *StarWarMessage {
	if m != nil {
		o := &StarWarMessage{}
		o.Id = m.Id
		o.Username = m.Username
		o.Alliance = m.Alliance
		o.Username1 = m.Username1
		o.Username2 = m.Username2
		o.City = m.City
		o.CityCoordinate = m.CityCoordinate.Clone()
		o.Team = m.Team
		o.Skill = m.Skill
		return o
	}
	return nil
}

func InitStarWarMessage() *StarWarMessage {
	m := &StarWarMessage{}
	m.FixNilFields()
	return m
}
func (m *StarWarMessage) FixNilFields() {
	if m != nil {

		if m.CityCoordinate == nil {
			m.CityCoordinate = &Coordinate{}
		}
		m.CityCoordinate.FixNilFields()

	}
}
func (m *TowerVision) Clone() *TowerVision {
	if m != nil {
		o := &TowerVision{}
		if len(m.Passes) > 0 {
			o.Passes = make(map[uint32]uint32, len(m.Passes))
			for k, e := range m.Passes {
				o.Passes[k] = e
			}
		}
		return o
	}
	return nil
}

func InitTowerVision() *TowerVision {
	m := &TowerVision{}
	m.FixNilFields()
	return m
}
func (m *TowerVision) FixNilFields() {
	if m != nil {

		if m.Passes == nil {
			m.Passes = make(map[uint32]uint32)
		}

	}
}
func (m *FreeTurntableInfo) Clone() *FreeTurntableInfo {
	if m != nil {
		o := &FreeTurntableInfo{}
		o.Data = m.Data.Clone()
		if len(m.Ids) > 0 {
			o.Ids = make(map[uint32]uint32, len(m.Ids))
			for k, e := range m.Ids {
				o.Ids[k] = e
			}
		}
		return o
	}
	return nil
}

func InitFreeTurntableInfo() *FreeTurntableInfo {
	m := &FreeTurntableInfo{}
	m.FixNilFields()
	return m
}
func (m *FreeTurntableInfo) FixNilFields() {
	if m != nil {

		if m.Data == nil {
			m.Data = &FreeTurntable{}
		}
		m.Data.FixNilFields()

		if m.Ids == nil {
			m.Ids = make(map[uint32]uint32)
		}

	}
}
func (m *FreeTurntable) Clone() *FreeTurntable {
	if m != nil {
		o := &FreeTurntable{}
		o.WeeklyTime = m.WeeklyTime
		o.Type = m.Type
		o.Round = m.Round
		if len(m.Goods) > 0 {
			o.Goods = make([]uint32, len(m.Goods))
			copy(o.Goods, m.Goods)
		}
		return o
	}
	return nil
}

func InitFreeTurntable() *FreeTurntable {
	m := &FreeTurntable{}
	m.FixNilFields()
	return m
}
func (m *FreeTurntable) FixNilFields() {
	if m != nil {

	}
}
func (m *FreeDraw) Clone() *FreeDraw {
	if m != nil {
		o := &FreeDraw{}
		o.WeeklyTime = m.WeeklyTime
		o.ActivityGroup = m.ActivityGroup
		o.Section = m.Section
		o.Group = m.Group
		o.Round = m.Round
		o.Start = m.Start
		if len(m.ChooseAwards) > 0 {
			o.ChooseAwards = make(map[uint32]*BigAward, len(m.ChooseAwards))
			for k, e := range m.ChooseAwards {
				o.ChooseAwards[k] = e.Clone()
			}
		}
		if len(m.Goods) > 0 {
			o.Goods = make(map[uint32]uint32, len(m.Goods))
			for k, e := range m.Goods {
				o.Goods[k] = e
			}
		}
		o.TaskGroup = m.TaskGroup.Clone()
		return o
	}
	return nil
}

func InitFreeDraw() *FreeDraw {
	m := &FreeDraw{}
	m.FixNilFields()
	return m
}
func (m *FreeDraw) FixNilFields() {
	if m != nil {

		if m.ChooseAwards == nil {
			m.ChooseAwards = make(map[uint32]*BigAward)
		}
		for _, itor := range m.ChooseAwards {
			itor.FixNilFields()
		}

		if m.Goods == nil {
			m.Goods = make(map[uint32]uint32)
		}

		if m.TaskGroup == nil {
			m.TaskGroup = &FreeDrawGroup{}
		}
		m.TaskGroup.FixNilFields()

	}
}
func (m *BigAward) Clone() *BigAward {
	if m != nil {
		o := &BigAward{}
		o.Pos = m.Pos
		o.Id = m.Id
		o.Awarded = m.Awarded
		return o
	}
	return nil
}

func InitBigAward() *BigAward {
	m := &BigAward{}
	m.FixNilFields()
	return m
}
func (m *BigAward) FixNilFields() {
	if m != nil {

	}
}
func (m *FreeDrawGroup) Clone() *FreeDrawGroup {
	if m != nil {
		o := &FreeDrawGroup{}
		o.Group = m.Group
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		if len(m.FinishTasks) > 0 {
			o.FinishTasks = make([]uint32, len(m.FinishTasks))
			copy(o.FinishTasks, m.FinishTasks)
		}
		return o
	}
	return nil
}

func InitFreeDrawGroup() *FreeDrawGroup {
	m := &FreeDrawGroup{}
	m.FixNilFields()
	return m
}
func (m *FreeDrawGroup) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

	}
}
func (m *OperateBossFormation) Clone() *OperateBossFormation {
	if m != nil {
		o := &OperateBossFormation{}
		if len(m.Pets) > 0 {
			o.Pets = make([]*PairU32, len(m.Pets))
			for k, e := range m.Pets {
				o.Pets[k] = e.Clone()
			}
		}
		if len(m.Horcruxes) > 0 {
			o.Horcruxes = make([]*PairU32, len(m.Horcruxes))
			for k, e := range m.Horcruxes {
				o.Horcruxes[k] = e.Clone()
			}
		}
		o.Throne = m.Throne.Clone()
		o.Fashion = m.Fashion.Clone()
		return o
	}
	return nil
}

func InitOperateBossFormation() *OperateBossFormation {
	m := &OperateBossFormation{}
	m.FixNilFields()
	return m
}
func (m *OperateBossFormation) FixNilFields() {
	if m != nil {

		for _, itor := range m.Pets {
			itor.FixNilFields()
		}

		for _, itor := range m.Horcruxes {
			itor.FixNilFields()
		}

		if m.Throne == nil {
			m.Throne = &SmallKV{}
		}
		m.Throne.FixNilFields()

		if m.Fashion == nil {
			m.Fashion = &SmallKV{}
		}
		m.Fashion.FixNilFields()

	}
}
func (m *OperateBoss) Clone() *OperateBoss {
	if m != nil {
		o := &OperateBoss{}
		o.LastChallenge = m.LastChallenge
		o.GetAward = m.GetAward
		o.Formation = m.Formation.Clone()
		o.MaxHarm = m.MaxHarm
		return o
	}
	return nil
}

func InitOperateBoss() *OperateBoss {
	m := &OperateBoss{}
	m.FixNilFields()
	return m
}
func (m *OperateBoss) FixNilFields() {
	if m != nil {

		if m.Formation == nil {
			m.Formation = &OperateBossFormation{}
		}
		m.Formation.FixNilFields()

	}
}
func (m *Tree) Clone() *Tree {
	if m != nil {
		o := &Tree{}
		o.Stage = m.Stage
		if len(m.Conditions) > 0 {
			o.Conditions = make(map[uint32]*Condition, len(m.Conditions))
			for k, e := range m.Conditions {
				o.Conditions[k] = e.Clone()
			}
		}
		o.Level = m.Level
		o.LevelExp = m.LevelExp
		o.Grade = m.Grade
		o.GradeExp = m.GradeExp
		if len(m.GradeExtraAttr) > 0 {
			o.GradeExtraAttr = make(map[uint32]*PairsU32S, len(m.GradeExtraAttr))
			for k, e := range m.GradeExtraAttr {
				o.GradeExtraAttr[k] = e.Clone()
			}
		}
		o.Initialize = m.Initialize
		return o
	}
	return nil
}

func InitTree() *Tree {
	m := &Tree{}
	m.FixNilFields()
	return m
}
func (m *Tree) FixNilFields() {
	if m != nil {

		if m.Conditions == nil {
			m.Conditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.Conditions {
			itor.FixNilFields()
		}

		if m.GradeExtraAttr == nil {
			m.GradeExtraAttr = make(map[uint32]*PairsU32S)
		}
		for _, itor := range m.GradeExtraAttr {
			itor.FixNilFields()
		}

	}
}
func (m *VipReturnFrom) Clone() *VipReturnFrom {
	if m != nil {
		o := &VipReturnFrom{}
		o.Group = m.Group
		o.ServerId = m.ServerId
		o.UserId = m.UserId
		o.UserName = m.UserName
		o.UserLevel = m.UserLevel
		o.UserVipLevel = m.UserVipLevel
		return o
	}
	return nil
}

func InitVipReturnFrom() *VipReturnFrom {
	m := &VipReturnFrom{}
	m.FixNilFields()
	return m
}
func (m *VipReturnFrom) FixNilFields() {
	if m != nil {

	}
}
func (m *VipReturnConfirm) Clone() *VipReturnConfirm {
	if m != nil {
		o := &VipReturnConfirm{}
		o.From = m.From.Clone()
		o.ConfirmTime = m.ConfirmTime
		if len(m.AwardDays) > 0 {
			o.AwardDays = make([]uint32, len(m.AwardDays))
			copy(o.AwardDays, m.AwardDays)
		}
		return o
	}
	return nil
}

func InitVipReturnConfirm() *VipReturnConfirm {
	m := &VipReturnConfirm{}
	m.FixNilFields()
	return m
}
func (m *VipReturnConfirm) FixNilFields() {
	if m != nil {

		if m.From == nil {
			m.From = &VipReturnFrom{}
		}
		m.From.FixNilFields()

	}
}
func (m *StarPeakMessages) Clone() *StarPeakMessages {
	if m != nil {
		o := &StarPeakMessages{}
		if len(m.Messages) > 0 {
			o.Messages = make([]*StarPeakMessage, len(m.Messages))
			for k, e := range m.Messages {
				o.Messages[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitStarPeakMessages() *StarPeakMessages {
	m := &StarPeakMessages{}
	m.FixNilFields()
	return m
}
func (m *StarPeakMessages) FixNilFields() {
	if m != nil {

		for _, itor := range m.Messages {
			itor.FixNilFields()
		}

	}
}
func (m *StarPeakMessage) Clone() *StarPeakMessage {
	if m != nil {
		o := &StarPeakMessage{}
		o.UserName1 = m.UserName1
		o.UserName2 = m.UserName2
		return o
	}
	return nil
}

func InitStarPeakMessage() *StarPeakMessage {
	m := &StarPeakMessage{}
	m.FixNilFields()
	return m
}
func (m *StarPeakMessage) FixNilFields() {
	if m != nil {

	}
}
func (m *StarPeakWatchSummary) Clone() *StarPeakWatchSummary {
	if m != nil {
		o := &StarPeakWatchSummary{}
		o.GroupId = m.GroupId
		o.StakeCount = m.StakeCount
		return o
	}
	return nil
}

func InitStarPeakWatchSummary() *StarPeakWatchSummary {
	m := &StarPeakWatchSummary{}
	m.FixNilFields()
	return m
}
func (m *StarPeakWatchSummary) FixNilFields() {
	if m != nil {

	}
}
func (m *StarPeakFightProgress) Clone() *StarPeakFightProgress {
	if m != nil {
		o := &StarPeakFightProgress{}
		o.LoopNum = m.LoopNum
		o.TeamProgress = m.TeamProgress
		o.State = m.State
		o.StateTime = m.StateTime
		o.Now = m.Now
		return o
	}
	return nil
}

func InitStarPeakFightProgress() *StarPeakFightProgress {
	m := &StarPeakFightProgress{}
	m.FixNilFields()
	return m
}
func (m *StarPeakFightProgress) FixNilFields() {
	if m != nil {

	}
}
func (m *StarPeakStakeInfo) Clone() *StarPeakStakeInfo {
	if m != nil {
		o := &StarPeakStakeInfo{}
		o.Uid = m.Uid
		o.StakeCount = m.StakeCount
		o.StakeRatio = m.StakeRatio
		return o
	}
	return nil
}

func InitStarPeakStakeInfo() *StarPeakStakeInfo {
	m := &StarPeakStakeInfo{}
	m.FixNilFields()
	return m
}
func (m *StarPeakStakeInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *StarPeakMatch) Clone() *StarPeakMatch {
	if m != nil {
		o := &StarPeakMatch{}
		o.FightOrder = m.FightOrder
		o.FightDay = m.FightDay
		o.TerrainId = m.TerrainId
		o.WinScore = m.WinScore
		o.GroupId = m.GroupId
		o.FightDayZero = m.FightDayZero
		o.FightProgress = m.FightProgress.Clone()
		if len(m.Skills) > 0 {
			o.Skills = make([]uint32, len(m.Skills))
			copy(o.Skills, m.Skills)
		}
		if len(m.WatchSummarys) > 0 {
			o.WatchSummarys = make([]*StarPeakWatchSummary, len(m.WatchSummarys))
			for k, e := range m.WatchSummarys {
				o.WatchSummarys[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitStarPeakMatch() *StarPeakMatch {
	m := &StarPeakMatch{}
	m.FixNilFields()
	return m
}
func (m *StarPeakMatch) FixNilFields() {
	if m != nil {

		if m.FightProgress == nil {
			m.FightProgress = &StarPeakFightProgress{}
		}
		m.FightProgress.FixNilFields()

		for _, itor := range m.WatchSummarys {
			itor.FixNilFields()
		}

	}
}
func (m *StarPeakDisplay) Clone() *StarPeakDisplay {
	if m != nil {
		o := &StarPeakDisplay{}
		if len(m.Users) > 0 {
			o.Users = make([]*RankValue, len(m.Users))
			for k, e := range m.Users {
				o.Users[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitStarPeakDisplay() *StarPeakDisplay {
	m := &StarPeakDisplay{}
	m.FixNilFields()
	return m
}
func (m *StarPeakDisplay) FixNilFields() {
	if m != nil {

		for _, itor := range m.Users {
			itor.FixNilFields()
		}

	}
}
func (m *StarPeakMyInfo) Clone() *StarPeakMyInfo {
	if m != nil {
		o := &StarPeakMyInfo{}
		o.IsFinal = m.IsFinal
		o.Rank = m.Rank
		o.AuditionDay = m.AuditionDay
		o.FightOrder = m.FightOrder
		o.FightDay = m.FightDay
		o.FightGroupId = m.FightGroupId
		return o
	}
	return nil
}

func InitStarPeakMyInfo() *StarPeakMyInfo {
	m := &StarPeakMyInfo{}
	m.FixNilFields()
	return m
}
func (m *StarPeakMyInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *StarPeakTeam) Clone() *StarPeakTeam {
	if m != nil {
		o := &StarPeakTeam{}
		o.TeamType = m.TeamType
		o.BattleData = m.BattleData.Clone()
		return o
	}
	return nil
}

func InitStarPeakTeam() *StarPeakTeam {
	m := &StarPeakTeam{}
	m.FixNilFields()
	return m
}
func (m *StarPeakTeam) FixNilFields() {
	if m != nil {

		if m.BattleData == nil {
			m.BattleData = &UserBattleData{}
		}
		m.BattleData.FixNilFields()

	}
}
func (m *StarPeakMatchUser) Clone() *StarPeakMatchUser {
	if m != nil {
		o := &StarPeakMatchUser{}
		o.Uid = m.Uid
		o.ServerId = m.ServerId
		o.WinScore = m.WinScore
		o.TeamDeploy = m.TeamDeploy
		o.StakeCount = m.StakeCount
		if len(m.TeamsHide) > 0 {
			o.TeamsHide = make([]uint32, len(m.TeamsHide))
			copy(o.TeamsHide, m.TeamsHide)
		}
		if len(m.TeamsUsed) > 0 {
			o.TeamsUsed = make([]uint32, len(m.TeamsUsed))
			copy(o.TeamsUsed, m.TeamsUsed)
		}
		if len(m.TeamsInOrder) > 0 {
			o.TeamsInOrder = make([]*StarPeakTeam, len(m.TeamsInOrder))
			for k, e := range m.TeamsInOrder {
				o.TeamsInOrder[k] = e.Clone()
			}
		}
		o.Head = m.Head.Clone()
		return o
	}
	return nil
}

func InitStarPeakMatchUser() *StarPeakMatchUser {
	m := &StarPeakMatchUser{}
	m.FixNilFields()
	return m
}
func (m *StarPeakMatchUser) FixNilFields() {
	if m != nil {

		for _, itor := range m.TeamsInOrder {
			itor.FixNilFields()
		}

		if m.Head == nil {
			m.Head = &UserBattleData{}
		}
		m.Head.FixNilFields()

	}
}
func (m *StarPeakTeamResult) Clone() *StarPeakTeamResult {
	if m != nil {
		o := &StarPeakTeamResult{}
		o.TeamType1 = m.TeamType1
		o.TeamType2 = m.TeamType2
		o.Win = m.Win
		return o
	}
	return nil
}

func InitStarPeakTeamResult() *StarPeakTeamResult {
	m := &StarPeakTeamResult{}
	m.FixNilFields()
	return m
}
func (m *StarPeakTeamResult) FixNilFields() {
	if m != nil {

	}
}
func (m *StarPeakPair) Clone() *StarPeakPair {
	if m != nil {
		o := &StarPeakPair{}
		o.Id = m.Id
		o.Uid1 = m.Uid1
		o.Uid2 = m.Uid2
		o.WinCount1 = m.WinCount1
		o.WinCount2 = m.WinCount2
		return o
	}
	return nil
}

func InitStarPeakPair() *StarPeakPair {
	m := &StarPeakPair{}
	m.FixNilFields()
	return m
}
func (m *StarPeakPair) FixNilFields() {
	if m != nil {

	}
}
func (m *StarPeakPairReport) Clone() *StarPeakPairReport {
	if m != nil {
		o := &StarPeakPairReport{}
		o.TeamType1 = m.TeamType1
		o.TeamType2 = m.TeamType2
		o.TeamAbsent1 = m.TeamAbsent1
		o.TeamAbsent2 = m.TeamAbsent2
		o.TeamPower1 = m.TeamPower1
		o.TeamPower2 = m.TeamPower2
		o.ReportId = m.ReportId
		o.Win = m.Win
		return o
	}
	return nil
}

func InitStarPeakPairReport() *StarPeakPairReport {
	m := &StarPeakPairReport{}
	m.FixNilFields()
	return m
}
func (m *StarPeakPairReport) FixNilFields() {
	if m != nil {

	}
}
func (m *StarPeakGroupUser) Clone() *StarPeakGroupUser {
	if m != nil {
		o := &StarPeakGroupUser{}
		o.Snap = m.Snap.Clone()
		o.WinScore = m.WinScore
		o.Rank = m.Rank
		o.StakeCount = m.StakeCount
		o.StakeRatio = m.StakeRatio
		return o
	}
	return nil
}

func InitStarPeakGroupUser() *StarPeakGroupUser {
	m := &StarPeakGroupUser{}
	m.FixNilFields()
	return m
}
func (m *StarPeakGroupUser) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *StarPeakTeamPower) Clone() *StarPeakTeamPower {
	if m != nil {
		o := &StarPeakTeamPower{}
		o.TeamType = m.TeamType
		o.Power = m.Power
		return o
	}
	return nil
}

func InitStarPeakTeamPower() *StarPeakTeamPower {
	m := &StarPeakTeamPower{}
	m.FixNilFields()
	return m
}
func (m *StarPeakTeamPower) FixNilFields() {
	if m != nil {

	}
}
func (m *StarPeakHistoryPart) Clone() *StarPeakHistoryPart {
	if m != nil {
		o := &StarPeakHistoryPart{}
		if len(m.Users) > 0 {
			o.Users = make([]*RankValue, len(m.Users))
			for k, e := range m.Users {
				o.Users[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitStarPeakHistoryPart() *StarPeakHistoryPart {
	m := &StarPeakHistoryPart{}
	m.FixNilFields()
	return m
}
func (m *StarPeakHistoryPart) FixNilFields() {
	if m != nil {

		for _, itor := range m.Users {
			itor.FixNilFields()
		}

	}
}
func (m *StarPeakHistorySeason) Clone() *StarPeakHistorySeason {
	if m != nil {
		o := &StarPeakHistorySeason{}
		o.SeasonId = m.SeasonId
		if len(m.Parts) > 0 {
			o.Parts = make(map[uint32]*StarPeakHistoryPart, len(m.Parts))
			for k, e := range m.Parts {
				o.Parts[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitStarPeakHistorySeason() *StarPeakHistorySeason {
	m := &StarPeakHistorySeason{}
	m.FixNilFields()
	return m
}
func (m *StarPeakHistorySeason) FixNilFields() {
	if m != nil {

		if m.Parts == nil {
			m.Parts = make(map[uint32]*StarPeakHistoryPart)
		}
		for _, itor := range m.Parts {
			itor.FixNilFields()
		}

	}
}
func (m *StarPeakSeasonTopName) Clone() *StarPeakSeasonTopName {
	if m != nil {
		o := &StarPeakSeasonTopName{}
		o.SeasonId = m.SeasonId
		o.UserName = m.UserName
		return o
	}
	return nil
}

func InitStarPeakSeasonTopName() *StarPeakSeasonTopName {
	m := &StarPeakSeasonTopName{}
	m.FixNilFields()
	return m
}
func (m *StarPeakSeasonTopName) FixNilFields() {
	if m != nil {

	}
}
func (m *StarPeakGroupInfo) Clone() *StarPeakGroupInfo {
	if m != nil {
		o := &StarPeakGroupInfo{}
		o.GroupId = m.GroupId
		o.FightOrder = m.FightOrder
		o.FightDay = m.FightDay
		return o
	}
	return nil
}

func InitStarPeakGroupInfo() *StarPeakGroupInfo {
	m := &StarPeakGroupInfo{}
	m.FixNilFields()
	return m
}
func (m *StarPeakGroupInfo) FixNilFields() {
	if m != nil {

	}
}
func (m *TourActivityRoom) Clone() *TourActivityRoom {
	if m != nil {
		o := &TourActivityRoom{}
		o.Room = m.Room
		o.UnlockNum = m.UnlockNum
		if len(m.Grids) > 0 {
			o.Grids = make(map[uint32]uint64, len(m.Grids))
			for k, e := range m.Grids {
				o.Grids[k] = e
			}
		}
		return o
	}
	return nil
}

func InitTourActivityRoom() *TourActivityRoom {
	m := &TourActivityRoom{}
	m.FixNilFields()
	return m
}
func (m *TourActivityRoom) FixNilFields() {
	if m != nil {

		if m.Grids == nil {
			m.Grids = make(map[uint32]uint64)
		}

	}
}
func (m *TourActivity) Clone() *TourActivity {
	if m != nil {
		o := &TourActivity{}
		o.Id = m.Id
		o.StartTime = m.StartTime
		o.ScoreTime = m.ScoreTime
		if len(m.AwardTimes) > 0 {
			o.AwardTimes = make(map[uint32]*Int64M, len(m.AwardTimes))
			for k, e := range m.AwardTimes {
				o.AwardTimes[k] = e.Clone()
			}
		}
		if len(m.Rooms) > 0 {
			o.Rooms = make([]*TourActivityRoom, len(m.Rooms))
			for k, e := range m.Rooms {
				o.Rooms[k] = e.Clone()
			}
		}
		if len(m.Awards) > 0 {
			o.Awards = make([]*Resource, len(m.Awards))
			for k, e := range m.Awards {
				o.Awards[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitTourActivity() *TourActivity {
	m := &TourActivity{}
	m.FixNilFields()
	return m
}
func (m *TourActivity) FixNilFields() {
	if m != nil {

		if m.AwardTimes == nil {
			m.AwardTimes = make(map[uint32]*Int64M)
		}
		for _, itor := range m.AwardTimes {
			itor.FixNilFields()
		}

		for _, itor := range m.Rooms {
			itor.FixNilFields()
		}

		for _, itor := range m.Awards {
			itor.FixNilFields()
		}

	}
}
func (m *TeamPvp) Clone() *TeamPvp {
	if m != nil {
		o := &TeamPvp{}
		o.TeamId = m.TeamId
		if len(m.ScoreAwardeds) > 0 {
			o.ScoreAwardeds = make([]uint32, len(m.ScoreAwardeds))
			copy(o.ScoreAwardeds, m.ScoreAwardeds)
		}
		if len(m.AppliedTeams) > 0 {
			o.AppliedTeams = make([]uint64, len(m.AppliedTeams))
			copy(o.AppliedTeams, m.AppliedTeams)
		}
		o.Score = m.Score
		o.Spirit = m.Spirit
		o.Stamina = m.Stamina
		o.LastRecoveryTime = m.LastRecoveryTime
		o.Stone = m.Stone
		if len(m.Boxes) > 0 {
			o.Boxes = make(map[uint32]uint32, len(m.Boxes))
			for k, e := range m.Boxes {
				o.Boxes[k] = e
			}
		}
		if len(m.Monsters) > 0 {
			o.Monsters = make(map[uint32]uint32, len(m.Monsters))
			for k, e := range m.Monsters {
				o.Monsters[k] = e
			}
		}
		if len(m.Treasures) > 0 {
			o.Treasures = make(map[uint32]uint32, len(m.Treasures))
			for k, e := range m.Treasures {
				o.Treasures[k] = e
			}
		}
		if len(m.TreasurePowers) > 0 {
			o.TreasurePowers = make(map[uint32]int64, len(m.TreasurePowers))
			for k, e := range m.TreasurePowers {
				o.TreasurePowers[k] = e
			}
		}
		if len(m.AssistTimes) > 0 {
			o.AssistTimes = make([]*TeamPvpAssistTime, len(m.AssistTimes))
			for k, e := range m.AssistTimes {
				o.AssistTimes[k] = e.Clone()
			}
		}
		o.AssistCnt = m.AssistCnt
		o.MapLayer = m.MapLayer
		o.MapEvent = m.MapEvent
		o.MapEventTriggerTime = m.MapEventTriggerTime
		o.MapEventMarkedId = m.MapEventMarkedId
		o.MonsterTeam = m.MonsterTeam
		o.EnemyId = m.EnemyId
		o.EnemyBattleData = m.EnemyBattleData.Clone()
		o.EnemySnap = m.EnemySnap.Clone()
		if len(m.Hps) > 0 {
			o.Hps = make([]*Pair, len(m.Hps))
			for k, e := range m.Hps {
				o.Hps[k] = e.Clone()
			}
		}
		if len(m.EnemyMainRoleHps) > 0 {
			o.EnemyMainRoleHps = make(map[uint32]int64, len(m.EnemyMainRoleHps))
			for k, e := range m.EnemyMainRoleHps {
				o.EnemyMainRoleHps[k] = e
			}
		}
		return o
	}
	return nil
}

func InitTeamPvp() *TeamPvp {
	m := &TeamPvp{}
	m.FixNilFields()
	return m
}
func (m *TeamPvp) FixNilFields() {
	if m != nil {

		if m.Boxes == nil {
			m.Boxes = make(map[uint32]uint32)
		}

		if m.Monsters == nil {
			m.Monsters = make(map[uint32]uint32)
		}

		if m.Treasures == nil {
			m.Treasures = make(map[uint32]uint32)
		}

		if m.TreasurePowers == nil {
			m.TreasurePowers = make(map[uint32]int64)
		}

		for _, itor := range m.AssistTimes {
			itor.FixNilFields()
		}

		if m.EnemyBattleData == nil {
			m.EnemyBattleData = &UserBattleData{}
		}
		m.EnemyBattleData.FixNilFields()

		if m.EnemySnap == nil {
			m.EnemySnap = &UserSnapshot{}
		}
		m.EnemySnap.FixNilFields()

		for _, itor := range m.Hps {
			itor.FixNilFields()
		}

		if m.EnemyMainRoleHps == nil {
			m.EnemyMainRoleHps = make(map[uint32]int64)
		}

	}
}
func (m *TeamPvpTeam) Clone() *TeamPvpTeam {
	if m != nil {
		o := &TeamPvpTeam{}
		o.Rank = m.Rank
		o.Id = m.Id
		o.Name = m.Name
		o.EntryCheck = m.EntryCheck
		o.EntryPower = m.EntryPower
		if len(m.Members) > 0 {
			o.Members = make(map[uint32]uint64, len(m.Members))
			for k, e := range m.Members {
				o.Members[k] = e
			}
		}
		if len(m.Applicants) > 0 {
			o.Applicants = make([]uint64, len(m.Applicants))
			copy(o.Applicants, m.Applicants)
		}
		if len(m.Assists) > 0 {
			o.Assists = make([]*TeamPvpAssist, len(m.Assists))
			for k, e := range m.Assists {
				o.Assists[k] = e.Clone()
			}
		}
		if len(m.Snaps) > 0 {
			o.Snaps = make([]*TeamPvpUserSnapshot, len(m.Snaps))
			for k, e := range m.Snaps {
				o.Snaps[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitTeamPvpTeam() *TeamPvpTeam {
	m := &TeamPvpTeam{}
	m.FixNilFields()
	return m
}
func (m *TeamPvpTeam) FixNilFields() {
	if m != nil {

		if m.Members == nil {
			m.Members = make(map[uint32]uint64)
		}

		for _, itor := range m.Assists {
			itor.FixNilFields()
		}

		for _, itor := range m.Snaps {
			itor.FixNilFields()
		}

	}
}
func (m *TeamPvpAssist) Clone() *TeamPvpAssist {
	if m != nil {
		o := &TeamPvpAssist{}
		o.Id = m.Id
		o.Uid = m.Uid
		o.AssistTime = m.AssistTime
		o.MapEvent = m.MapEvent
		o.MonsterTeam = m.MonsterTeam
		o.EnemyId = m.EnemyId
		o.Defeated = m.Defeated
		o.Spirit = m.Spirit
		if len(m.Treasures) > 0 {
			o.Treasures = make(map[uint32]uint32, len(m.Treasures))
			for k, e := range m.Treasures {
				o.Treasures[k] = e
			}
		}
		o.EnemyBattleData = m.EnemyBattleData.Clone()
		o.EnemySnap = m.EnemySnap.Clone()
		if len(m.Hps) > 0 {
			o.Hps = make([]*Pair, len(m.Hps))
			for k, e := range m.Hps {
				o.Hps[k] = e.Clone()
			}
		}
		if len(m.EnemyMainRoleHps) > 0 {
			o.EnemyMainRoleHps = make(map[uint32]int64, len(m.EnemyMainRoleHps))
			for k, e := range m.EnemyMainRoleHps {
				o.EnemyMainRoleHps[k] = e
			}
		}
		return o
	}
	return nil
}

func InitTeamPvpAssist() *TeamPvpAssist {
	m := &TeamPvpAssist{}
	m.FixNilFields()
	return m
}
func (m *TeamPvpAssist) FixNilFields() {
	if m != nil {

		if m.Treasures == nil {
			m.Treasures = make(map[uint32]uint32)
		}

		if m.EnemyBattleData == nil {
			m.EnemyBattleData = &UserBattleData{}
		}
		m.EnemyBattleData.FixNilFields()

		if m.EnemySnap == nil {
			m.EnemySnap = &UserSnapshot{}
		}
		m.EnemySnap.FixNilFields()

		for _, itor := range m.Hps {
			itor.FixNilFields()
		}

		if m.EnemyMainRoleHps == nil {
			m.EnemyMainRoleHps = make(map[uint32]int64)
		}

	}
}
func (m *TeamPvpAssistTime) Clone() *TeamPvpAssistTime {
	if m != nil {
		o := &TeamPvpAssistTime{}
		o.Id = m.Id
		o.Tm = m.Tm
		return o
	}
	return nil
}

func InitTeamPvpAssistTime() *TeamPvpAssistTime {
	m := &TeamPvpAssistTime{}
	m.FixNilFields()
	return m
}
func (m *TeamPvpAssistTime) FixNilFields() {
	if m != nil {

	}
}
func (m *TeamPvpUserSnapshot) Clone() *TeamPvpUserSnapshot {
	if m != nil {
		o := &TeamPvpUserSnapshot{}
		o.Uid = m.Uid
		o.MapLayer = m.MapLayer
		o.Spirit = m.Spirit
		o.Power = m.Power
		o.Snap = m.Snap.Clone()
		return o
	}
	return nil
}

func InitTeamPvpUserSnapshot() *TeamPvpUserSnapshot {
	m := &TeamPvpUserSnapshot{}
	m.FixNilFields()
	return m
}
func (m *TeamPvpUserSnapshot) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *TeamPvpTeamRankValue) Clone() *TeamPvpTeamRankValue {
	if m != nil {
		o := &TeamPvpTeamRankValue{}
		o.Rank = m.Rank
		o.Value = m.Value
		o.Name = m.Name
		if len(m.Snaps) > 0 {
			o.Snaps = make([]*TeamPvpUserSnapshot, len(m.Snaps))
			for k, e := range m.Snaps {
				o.Snaps[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitTeamPvpTeamRankValue() *TeamPvpTeamRankValue {
	m := &TeamPvpTeamRankValue{}
	m.FixNilFields()
	return m
}
func (m *TeamPvpTeamRankValue) FixNilFields() {
	if m != nil {

		for _, itor := range m.Snaps {
			itor.FixNilFields()
		}

	}
}
func (m *TeamPvpNotifyTeam) Clone() *TeamPvpNotifyTeam {
	if m != nil {
		o := &TeamPvpNotifyTeam{}
		o.Uid = m.Uid
		o.Apply = m.Apply
		o.Approve = m.Approve
		o.Kick = m.Kick
		o.Leave = m.Leave
		o.Dismiss = m.Dismiss
		return o
	}
	return nil
}

func InitTeamPvpNotifyTeam() *TeamPvpNotifyTeam {
	m := &TeamPvpNotifyTeam{}
	m.FixNilFields()
	return m
}
func (m *TeamPvpNotifyTeam) FixNilFields() {
	if m != nil {

	}
}
func (m *TeamPvpNotifyEvent) Clone() *TeamPvpNotifyEvent {
	if m != nil {
		o := &TeamPvpNotifyEvent{}
		o.Mark = m.Mark
		o.Assist = m.Assist
		o.Defeated = m.Defeated
		o.Snap = m.Snap.Clone()
		if len(m.Treasures) > 0 {
			o.Treasures = make(map[uint32]uint32, len(m.Treasures))
			for k, e := range m.Treasures {
				o.Treasures[k] = e
			}
		}
		return o
	}
	return nil
}

func InitTeamPvpNotifyEvent() *TeamPvpNotifyEvent {
	m := &TeamPvpNotifyEvent{}
	m.FixNilFields()
	return m
}
func (m *TeamPvpNotifyEvent) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

		if m.Treasures == nil {
			m.Treasures = make(map[uint32]uint32)
		}

	}
}
func (m *FightEntrance) Clone() *FightEntrance {
	if m != nil {
		o := &FightEntrance{}
		o.Type = m.Type
		o.StartTime = m.StartTime
		return o
	}
	return nil
}

func InitFightEntrance() *FightEntrance {
	m := &FightEntrance{}
	m.FixNilFields()
	return m
}
func (m *FightEntrance) FixNilFields() {
	if m != nil {

	}
}
func (m *StruggleMyBase) Clone() *StruggleMyBase {
	if m != nil {
		o := &StruggleMyBase{}
		o.Score = m.Score
		o.ContinueWinNum = m.ContinueWinNum
		o.LocalRank = m.LocalRank
		o.CrossRank = m.CrossRank
		o.UpRankNeedScore = m.UpRankNeedScore
		o.UpRankTo = m.UpRankTo
		o.LeftChallengeNum = m.LeftChallengeNum
		o.ChallengedEnemyNum = m.ChallengedEnemyNum
		if len(m.TaskConditions) > 0 {
			o.TaskConditions = make(map[uint32]*Condition, len(m.TaskConditions))
			for k, e := range m.TaskConditions {
				o.TaskConditions[k] = e.Clone()
			}
		}
		if len(m.AwardTaskIds) > 0 {
			o.AwardTaskIds = make([]uint32, len(m.AwardTaskIds))
			copy(o.AwardTaskIds, m.AwardTaskIds)
		}
		o.LastChallengeEnemyTime = m.LastChallengeEnemyTime
		if len(m.SelectSkills) > 0 {
			o.SelectSkills = make([]uint32, len(m.SelectSkills))
			copy(o.SelectSkills, m.SelectSkills)
		}
		if len(m.SkillNums) > 0 {
			o.SkillNums = make(map[uint32]uint32, len(m.SkillNums))
			for k, e := range m.SkillNums {
				o.SkillNums[k] = e
			}
		}
		if len(m.DailyTaskConditions) > 0 {
			o.DailyTaskConditions = make(map[uint32]*Condition, len(m.DailyTaskConditions))
			for k, e := range m.DailyTaskConditions {
				o.DailyTaskConditions[k] = e.Clone()
			}
		}
		if len(m.AwardDailyTaskIds) > 0 {
			o.AwardDailyTaskIds = make([]uint32, len(m.AwardDailyTaskIds))
			copy(o.AwardDailyTaskIds, m.AwardDailyTaskIds)
		}
		o.DailyChallengeEnemyNum = m.DailyChallengeEnemyNum
		return o
	}
	return nil
}

func InitStruggleMyBase() *StruggleMyBase {
	m := &StruggleMyBase{}
	m.FixNilFields()
	return m
}
func (m *StruggleMyBase) FixNilFields() {
	if m != nil {

		if m.TaskConditions == nil {
			m.TaskConditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.TaskConditions {
			itor.FixNilFields()
		}

		if m.SkillNums == nil {
			m.SkillNums = make(map[uint32]uint32)
		}

		if m.DailyTaskConditions == nil {
			m.DailyTaskConditions = make(map[uint32]*Condition)
		}
		for _, itor := range m.DailyTaskConditions {
			itor.FixNilFields()
		}

	}
}
func (m *StruggleEnemy) Clone() *StruggleEnemy {
	if m != nil {
		o := &StruggleEnemy{}
		o.Snap = m.Snap.Clone()
		o.ContinueWinNum = m.ContinueWinNum
		o.Score = m.Score
		o.CrossRank = m.CrossRank
		return o
	}
	return nil
}

func InitStruggleEnemy() *StruggleEnemy {
	m := &StruggleEnemy{}
	m.FixNilFields()
	return m
}
func (m *StruggleEnemy) FixNilFields() {
	if m != nil {

		if m.Snap == nil {
			m.Snap = &UserSnapshot{}
		}
		m.Snap.FixNilFields()

	}
}
func (m *StruggleEnemyBrief) Clone() *StruggleEnemyBrief {
	if m != nil {
		o := &StruggleEnemyBrief{}
		o.UserId = m.UserId
		o.ContinueWinNum = m.ContinueWinNum
		o.Score = m.Score
		o.CrossRank = m.CrossRank
		return o
	}
	return nil
}

func InitStruggleEnemyBrief() *StruggleEnemyBrief {
	m := &StruggleEnemyBrief{}
	m.FixNilFields()
	return m
}
func (m *StruggleEnemyBrief) FixNilFields() {
	if m != nil {

	}
}
func (m *StruggleBriefVideo) Clone() *StruggleBriefVideo {
	if m != nil {
		o := &StruggleBriefVideo{}
		o.Id = m.Id
		o.Time = m.Time
		o.Win = m.Win
		o.Attacker = m.Attacker.Clone()
		o.Defender = m.Defender.Clone()
		o.AttackerScore = m.AttackerScore
		o.AttackerChangeScore = m.AttackerChangeScore
		o.DefenderScore = m.DefenderScore
		o.DefenderChangeScore = m.DefenderChangeScore
		return o
	}
	return nil
}

func InitStruggleBriefVideo() *StruggleBriefVideo {
	m := &StruggleBriefVideo{}
	m.FixNilFields()
	return m
}
func (m *StruggleBriefVideo) FixNilFields() {
	if m != nil {

		if m.Attacker == nil {
			m.Attacker = &UserSnapshot{}
		}
		m.Attacker.FixNilFields()

		if m.Defender == nil {
			m.Defender = &UserSnapshot{}
		}
		m.Defender.FixNilFields()

	}
}
func (m *StruggleCombatChat) Clone() *StruggleCombatChat {
	if m != nil {
		o := &StruggleCombatChat{}
		o.Id = m.Id
		o.ServerId1 = m.ServerId1
		o.UserName1 = m.UserName1
		o.ServerId2 = m.ServerId2
		o.UserName2 = m.UserName2
		o.WinNum = m.WinNum
		o.AnnounceId = m.AnnounceId
		return o
	}
	return nil
}

func InitStruggleCombatChat() *StruggleCombatChat {
	m := &StruggleCombatChat{}
	m.FixNilFields()
	return m
}
func (m *StruggleCombatChat) FixNilFields() {
	if m != nil {

	}
}
func (m *BuiltinActivity) Clone() *BuiltinActivity {
	if m != nil {
		o := &BuiltinActivity{}
		o.Type = m.Type
		o.ResetTime = m.ResetTime
		if len(m.Giftbags) > 0 {
			o.Giftbags = make([]*BuiltinGiftbag, len(m.Giftbags))
			for k, e := range m.Giftbags {
				o.Giftbags[k] = e.Clone()
			}
		}
		if len(m.Exchanges) > 0 {
			o.Exchanges = make([]*BuiltinExchange, len(m.Exchanges))
			for k, e := range m.Exchanges {
				o.Exchanges[k] = e.Clone()
			}
		}
		return o
	}
	return nil
}

func InitBuiltinActivity() *BuiltinActivity {
	m := &BuiltinActivity{}
	m.FixNilFields()
	return m
}
func (m *BuiltinActivity) FixNilFields() {
	if m != nil {

		for _, itor := range m.Giftbags {
			itor.FixNilFields()
		}

		for _, itor := range m.Exchanges {
			itor.FixNilFields()
		}

	}
}
func (m *BuiltinGiftbag) Clone() *BuiltinGiftbag {
	if m != nil {
		o := &BuiltinGiftbag{}
		o.Group = m.Group
		o.Step = m.Step
		o.Count = m.Count
		o.Type = m.Type
		o.Time = m.Time
		return o
	}
	return nil
}

func InitBuiltinGiftbag() *BuiltinGiftbag {
	m := &BuiltinGiftbag{}
	m.FixNilFields()
	return m
}
func (m *BuiltinGiftbag) FixNilFields() {
	if m != nil {

	}
}
func (m *BuiltinExchange) Clone() *BuiltinExchange {
	if m != nil {
		o := &BuiltinExchange{}
		o.Id = m.Id
		o.Count = m.Count
		o.Type = m.Type
		o.Time = m.Time
		return o
	}
	return nil
}

func InitBuiltinExchange() *BuiltinExchange {
	m := &BuiltinExchange{}
	m.FixNilFields()
	return m
}
func (m *BuiltinExchange) FixNilFields() {
	if m != nil {

	}
}
